Upload 23 files

.env

@@ -0,0 +1,15 @@
+# 基础API配置
+API_KEY=sk-enngzpiipobubtkttbootznwkyamairlpxzcoyngeenpqldd
+BASE_URL=https://api.siliconflow.cn/v1
+EMBEDDING_MODEL=BAAI/bge-m3
+RERANK_MODEL=BAAI/bge-reranker-v2-m3
+VISION_MODEL=Qwen/Qwen2.5-VL-72B-Instruct
+
+# Elasticsearch配置
+PASSWORD=zhx123456
+
+# 流式文本问答配置
+STREAM_API_KEY=sk-TqiNvIAcOuYkfdjn7fAf0a29E32a4eF49f376b151f075770
+STREAM_BASE_URL=https://api.oaipro.com/v1
+STREAM_MODEL=gpt-4o-mini
+DEFAULT_MODEL=gpt-4o-mini

agents/agent_10f4dc45_1742739896.json

@@ -0,0 +1,30 @@
+{
+  "id": "agent_10f4dc45_1742739896",
+  "name": "Python助教",
+  "description": "可以编写和执行Python代码辅助学习编程",
+  "subject": "Python",
+  "instructor": "李志刚教授",
+  "created_at": 1742739896,
+  "plugins": [
+    "code",
+    "mindmap"
+  ],
+  "knowledge_bases": [],
+  "workflow": {
+    "nodes": [],
+    "edges": []
+  },
+  "distributions": [
+    {
+      "id": "dist_388637",
+      "created_at": 1742739902,
+      "token": "f733d0fce2394e58b8fd0a21a9e0e83e",
+      "expires_at": 0,
+      "usage_count": 3
+    }
+  ],
+  "stats": {
+    "usage_count": 3,
+    "last_used": 1742740060
+  }
+}

agents/agent_2fb5faf5_1742706102.json

@@ -0,0 +1,85 @@
+{
+  "id": "agent_2fb5faf5_1742706102",
+  "name": "计算机组成原理助教",
+  "description": "会借助所有与计算机组成原理相关的知识库辅助问答，不额外使用多余的插件",
+  "subject": "计算机组成原理",
+  "instructor": "李志刚教授",
+  "created_at": 1742706102,
+  "plugins": [],
+  "knowledge_bases": [
+    "rag_计算机组成原理课程视频",
+    "rag_计算机组成原理"
+  ],
+  "workflow": {
+    "edges": [
+      {
+        "condition": "优先查询视频知识库",
+        "id": "edge1",
+        "source": "node1",
+        "target": "node2"
+      },
+      {
+        "condition": "有结果",
+        "id": "edge2",
+        "source": "node2",
+        "target": "node4"
+      },
+      {
+        "condition": "视频知识库无结果",
+        "id": "edge3",
+        "source": "node1",
+        "target": "node3"
+      },
+      {
+        "id": "edge4",
+        "source": "node3",
+        "target": "node4"
+      }
+    ],
+    "nodes": [
+      {
+        "data": {
+          "name": "意图识别"
+        },
+        "id": "node1",
+        "type": "intent_recognition"
+      },
+      {
+        "data": {
+          "knowledge_base_id": "rag_计算机组成原理课程视频",
+          "name": "知识库查询"
+        },
+        "id": "node2",
+        "type": "knowledge_query"
+      },
+      {
+        "data": {
+          "knowledge_base_id": "rag_计算机组成原理",
+          "name": "知识库查询"
+        },
+        "id": "node3",
+        "type": "knowledge_query"
+      },
+      {
+        "data": {
+          "name": "生成回复"
+        },
+        "id": "node4",
+        "type": "generate_response"
+      }
+    ]
+  },
+  "distributions": [
+    {
+      "id": "dist_f273d6",
+      "created_at": 1742706113,
+      "token": "1fe9aafc609f413fb1de8c92e05e08e7",
+      "expires_at": 0,
+      "usage_count": 1
+    }
+  ],
+  "stats": {
+    "usage_count": 1,
+    "last_used": 1742706127
+  }
+}

agents/agent_354996b8_1742743575.json

@@ -0,0 +1,101 @@
+{
+  "id": "agent_354996b8_1742743575",
+  "name": "Python助教2",
+  "description": "可以主动的调用python插件运行代码",
+  "subject": "Python",
+  "instructor": "李志刚教授",
+  "created_at": 1742743575,
+  "plugins": [
+    "code"
+  ],
+  "knowledge_bases": [
+    "rag_计算机组成原理课程视频",
+    "rag_计算机组成原理",
+    "rag_高等数学视频"
+  ],
+  "workflow": {
+    "edges": [
+      {
+        "condition": "需要知识",
+        "id": "edge1",
+        "source": "node1",
+        "target": "node2"
+      },
+      {
+        "condition": "需要代码执行",
+        "id": "edge2",
+        "source": "node1",
+        "target": "node3"
+      },
+      {
+        "id": "edge3",
+        "source": "node2",
+        "target": "node4"
+      },
+      {
+        "id": "edge4",
+        "source": "node3",
+        "target": "node4"
+      }
+    ],
+    "nodes": [
+      {
+        "data": {
+          "name": "意图识别"
+        },
+        "id": "node1",
+        "type": "intent_recognition"
+      },
+      {
+        "data": {
+          "knowledge_base_id": "rag_计算机组成原理课程视频",
+          "name": "知识库查询"
+        },
+        "id": "node2",
+        "type": "knowledge_query"
+      },
+      {
+        "data": {
+          "name": "调用代码执行插件",
+          "plugin_id": "code"
+        },
+        "id": "node3",
+        "type": "plugin_call"
+      },
+      {
+        "data": {
+          "name": "生成回复"
+        },
+        "id": "node4",
+        "type": "generate_response"
+      }
+    ]
+  },
+  "distributions": [
+    {
+      "id": "dist_1749ca",
+      "created_at": 1742743611,
+      "token": "db1779829c2b4ce5920be2181574655c",
+      "expires_at": 0,
+      "usage_count": 0
+    },
+    {
+      "id": "dist_eaa6a1",
+      "created_at": 1742955236,
+      "token": "6468d351bdc34a30a6ebcfad4d559890",
+      "expires_at": 0,
+      "usage_count": 2
+    },
+    {
+      "id": "dist_acab19",
+      "created_at": 1742956891,
+      "token": "30c40751c905427ba3e5afb2f48a1889",
+      "expires_at": 0,
+      "usage_count": 0
+    }
+  ],
+  "stats": {
+    "usage_count": 2,
+    "last_used": 1742956769
+  }
+}

agents/agent_6a80c7ea_1742729316.json

@@ -0,0 +1,50 @@
+{
+  "id": "agent_6a80c7ea_1742729316",
+  "name": "高等数学2",
+  "description": "高等数学",
+  "subject": "高等数学",
+  "instructor": "李志刚教授",
+  "created_at": 1742729316,
+  "plugins": [
+    "mindmap"
+  ],
+  "knowledge_bases": [],
+  "workflow": {
+    "nodes": [],
+    "edges": []
+  },
+  "distributions": [
+    {
+      "id": "dist_7d8bdd",
+      "created_at": 1742729323,
+      "token": "29564d0449e347449e7366eb0dfb5564",
+      "expires_at": 0,
+      "usage_count": 5
+    },
+    {
+      "id": "dist_de5c84",
+      "created_at": 1742733494,
+      "token": "dab67c87cccd44c8afdd7de415912e8b",
+      "expires_at": 0,
+      "usage_count": 1
+    },
+    {
+      "id": "dist_98e524",
+      "created_at": 1742733958,
+      "token": "2cee854d84e844aa895b0941d71f0c2c",
+      "expires_at": 0,
+      "usage_count": 1
+    },
+    {
+      "id": "dist_c86df7",
+      "created_at": 1742955361,
+      "token": "645ff249fba0437c9148a78decae2f7b",
+      "expires_at": 0,
+      "usage_count": 2
+    }
+  ],
+  "stats": {
+    "usage_count": 9,
+    "last_used": 1742956513
+  }
+}

agents/agent_bff4886f_1742724690.json

@@ -0,0 +1,50 @@
+{
+  "id": "agent_bff4886f_1742724690",
+  "name": "高等数学",
+  "description": "基于本地知识库的高等数学课程助教",
+  "subject": "高等数学",
+  "instructor": "李志刚教授",
+  "created_at": 1742724690,
+  "plugins": [
+    "visualization"
+  ],
+  "knowledge_bases": [],
+  "workflow": {
+    "nodes": [],
+    "edges": []
+  },
+  "distributions": [
+    {
+      "id": "dist_627b13",
+      "created_at": 1742732156,
+      "token": "4781dc4214e041b38b1935eb4bb2e592",
+      "expires_at": 0,
+      "usage_count": 4
+    },
+    {
+      "id": "dist_123907",
+      "created_at": 1742733536,
+      "token": "84bc8e25700c48f9ab006a33b92a0040",
+      "expires_at": 0,
+      "usage_count": 1
+    },
+    {
+      "id": "dist_f65e32",
+      "created_at": 1742734008,
+      "token": "6df809fc2b194a73ac94446979752575",
+      "expires_at": 0,
+      "usage_count": 1
+    },
+    {
+      "id": "dist_9614d5",
+      "created_at": 1742955410,
+      "token": "b4f594893f87470680b9ee5a739699e1",
+      "expires_at": 0,
+      "usage_count": 4
+    }
+  ],
+  "stats": {
+    "usage_count": 10,
+    "last_used": 1742956846
+  }
+}

agents/agent_d4b3238b_1742733873.json

@@ -0,0 +1,91 @@
+{
+  "id": "agent_d4b3238b_1742733873",
+  "name": "计算机组成原理助教2.0",
+  "description": "会借助所有与计算机组成原理相关的知识库辅助问答，不额外使用多余的插件",
+  "subject": "计算机组成原理",
+  "instructor": "李志刚教授",
+  "created_at": 1742733873,
+  "plugins": [],
+  "knowledge_bases": [
+    "rag_计算机组成原理课程视频",
+    "rag_计算机组成原理"
+  ],
+  "workflow": {
+    "edges": [
+      {
+        "condition": "需要知识",
+        "id": "edge1",
+        "source": "node1",
+        "target": "node2"
+      },
+      {
+        "id": "edge2",
+        "source": "node2",
+        "target": "node4"
+      },
+      {
+        "condition": "需要知识",
+        "id": "edge3",
+        "source": "node1",
+        "target": "node3"
+      },
+      {
+        "id": "edge4",
+        "source": "node3",
+        "target": "node4"
+      }
+    ],
+    "nodes": [
+      {
+        "data": {
+          "name": "意图识别"
+        },
+        "id": "node1",
+        "type": "intent_recognition"
+      },
+      {
+        "data": {
+          "knowledge_base_id": "rag_计算机组成原理课程视频",
+          "name": "知识库查询"
+        },
+        "id": "node2",
+        "type": "knowledge_query"
+      },
+      {
+        "data": {
+          "knowledge_base_id": "rag_计算机组成原理",
+          "name": "知识库查询"
+        },
+        "id": "node3",
+        "type": "knowledge_query"
+      },
+      {
+        "data": {
+          "name": "生成回复"
+        },
+        "id": "node4",
+        "type": "generate_response"
+      }
+    ]
+  },
+  "distributions": [
+    {
+      "id": "dist_832b92",
+      "created_at": 1742733904,
+      "token": "9c60e6d2343240018588c6044bfd0531",
+      "expires_at": 0,
+      "usage_count": 1
+    },
+    {
+      "id": "dist_688ac8",
+      "created_at": 1742955257,
+      "token": "c8d5092db34f4fe69d6a184eae06330e",
+      "expires_at": 0,
+      "usage_count": 1
+    }
+  ],
+  "stats": {
+    "usage_count": 2,
+    "last_used": 1742955313
+  }
+}

app.py

@@ -0,0 +1,517 @@
+from flask import Flask, request, jsonify, send_from_directory, render_template, redirect, url_for
+from flask_cors import CORS
+import os
+import time
+import traceback
+import json
+import re
+import sys
+import io
+import threading
+import queue
+import contextlib
+import signal
+import psutil
+from dotenv import load_dotenv
+
+# 导入模块路由
+from modules.knowledge_base.routes import knowledge_bp
+from modules.code_executor.routes import code_executor_bp
+from modules.visualization.routes import visualization_bp
+from modules.agent_builder.routes import agent_builder_bp
+
+# 加载环境变量
+load_dotenv()
+
+app = Flask(__name__)
+CORS(app)
+
+# 注册蓝图
+app.register_blueprint(knowledge_bp, url_prefix='/api/knowledge')
+app.register_blueprint(code_executor_bp, url_prefix='/api/code')
+app.register_blueprint(visualization_bp, url_prefix='/api/visualization')
+app.register_blueprint(agent_builder_bp, url_prefix='/api/agent')
+
+# 确保目录存在
+os.makedirs('static', exist_ok=True)
+os.makedirs('uploads', exist_ok=True)
+os.makedirs('agents', exist_ok=True)
+
+# 用于代码执行的上下文
+execution_contexts = {}
+
+def get_memory_usage():
+    """获取当前进程的内存使用情况"""
+    process = psutil.Process(os.getpid())
+    return f"{process.memory_info().rss / 1024 / 1024:.1f} MB"
+
+class CustomStdin:
+    def __init__(self, input_queue):
+        self.input_queue = input_queue
+        self.buffer = ""
+    
+    def readline(self):
+        if not self.buffer:
+            self.buffer = self.input_queue.get() + "\n"
+        
+        result = self.buffer
+        self.buffer = ""
+        return result
+
+class InteractiveExecution:
+    """管理Python代码的交互式执行"""
+    def __init__(self, code):
+        self.code = code
+        self.context_id = str(time.time())
+        self.is_complete = False
+        self.is_waiting_for_input = False
+        self.stdout_buffer = io.StringIO()
+        self.last_read_position = 0
+        self.input_queue = queue.Queue()
+        self.error = None
+        self.thread = None
+        self.should_terminate = False
+    
+    def run(self):
+        """在单独的线程中启动执行"""
+        self.thread = threading.Thread(target=self._execute)
+        self.thread.daemon = True
+        self.thread.start()
+        
+        # 给执行一点时间开始
+        time.sleep(0.1)
+        return self.context_id
+    
+    def _execute(self):
+        """执行代码，处理标准输入输出"""
+        try:
+            # 保存原始的stdin/stdout
+            orig_stdin = sys.stdin
+            orig_stdout = sys.stdout
+            
+            # 创建自定义stdin
+            custom_stdin = CustomStdin(self.input_queue)
+            
+            # 重定向stdin和stdout
+            sys.stdin = custom_stdin
+            sys.stdout = self.stdout_buffer
+            
+            try:
+                # 检查终止的函数
+                self._last_check_time = 0
+                
+                def check_termination():
+                    if self.should_terminate:
+                        raise KeyboardInterrupt("Execution terminated by user")
+                
+                # 设置一个模拟__main__模块的命名空间
+                shared_namespace = {
+                    "__builtins__": __builtins__,
+                    "_check_termination": check_termination,
+                    "time": time, 
+                    "__name__": "__main__"
+                }
+                
+                # 在这个命名空间中执行用户代码
+                try:
+                    exec(self.code, shared_namespace)
+                except KeyboardInterrupt:
+                    print("\nExecution terminated by user")
+                
+            except Exception as e:
+                self.error = {
+                    "error": str(e),
+                    "traceback": traceback.format_exc()
+                }
+            
+            finally:
+                # 恢复原始stdin/stdout
+                sys.stdin = orig_stdin
+                sys.stdout = orig_stdout
+                
+                # 标记执行完成
+                self.is_complete = True
+                
+        except Exception as e:
+            self.error = {
+                "error": str(e),
+                "traceback": traceback.format_exc()
+            }
+            self.is_complete = True
+    
+    def terminate(self):
+        """终止执行"""
+        self.should_terminate = True
+        
+        # 如果在等待输入，放入一些内容以解除阻塞
+        if self.is_waiting_for_input:
+            self.input_queue.put("\n")
+        
+        # 给执行一点时间终止
+        time.sleep(0.2)
+        
+        # 标记为完成
+        self.is_complete = True
+        
+        return True
+    
+    def provide_input(self, user_input):
+        """为运行的代码提供输入"""
+        self.input_queue.put(user_input)
+        self.is_waiting_for_input = False
+        return True
+    
+    def get_output(self):
+        """获取stdout缓冲区的当前内容"""
+        output = self.stdout_buffer.getvalue()
+        return output
+        
+    def get_new_output(self):
+        """只获取自上次读取以来的新输出"""
+        current_value = self.stdout_buffer.getvalue()
+        if self.last_read_position < len(current_value):
+            new_output = current_value[self.last_read_position:]
+            self.last_read_position = len(current_value)
+            return new_output
+        return ""
+
+@app.route('/')
+def index():
+    """主界面"""
+    return render_template('index.html')
+@app.route('/code_execution.html')
+def index2():
+    """主界面"""
+    return render_template('code_execution.html')
+@app.route('/api/progress/<task_id>', methods=['GET'])
+def get_progress(task_id):
+    """获取文档处理进度"""
+    try:
+        # 从知识库模块访问处理任务
+        from modules.knowledge_base.routes import processing_tasks
+        
+        progress_data = processing_tasks.get(task_id, {
+            'progress': 0,
+            'status': '未找到任务',
+            'error': True
+        })
+        
+        return jsonify({"success": True, "data": progress_data})
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"success": False, "message": str(e)}), 500
+
+@app.route('/student/<agent_id>')
+def student_view(agent_id):
+    """学生访问Agent界面"""
+    token = request.args.get('token', '')
+    
+    # 验证Agent存在
+    agent_path = os.path.join('agents', f"{agent_id}.json")
+    if not os.path.exists(agent_path):
+        return render_template('error.html', 
+                              message="找不到指定的Agent",
+                              error_code=404)
+    
+    # 加载Agent配置
+    with open(agent_path, 'r', encoding='utf-8') as f:
+        try:
+            agent_config = json.load(f)
+        except:
+            return render_template('error.html', 
+                                  message="Agent配置无效",
+                                  error_code=500)
+    
+    # 验证访问令牌
+    if token:
+        valid_token = False
+        if "distributions" in agent_config:
+            for dist in agent_config["distributions"]:
+                if dist.get("token") == token:
+                    valid_token = True
+                    break
+        
+        if not valid_token:
+            return render_template('error.html', 
+                                  message="访问令牌无效",
+                                  error_code=403)
+    
+    # 渲染学生页面
+    return render_template('student.html', 
+                          agent_id=agent_id,
+                          agent_name=agent_config.get('name', 'AI学习助手'),
+                          agent_description=agent_config.get('description', ''),
+                          token=token)
+
+@app.route('/code_execution.html')
+def code_execution_page():
+    """代码执行页面"""
+    return send_from_directory(os.path.dirname(os.path.abspath(__file__)), 'code_execution.html')
+
+@app.route('/api/student/chat/<agent_id>', methods=['POST'])
+def student_chat(agent_id):
+    """学生与Agent聊天的API"""
+    try:
+        data = request.json
+        message = data.get('message', '')
+        token = data.get('token', '')
+        
+        if not message:
+            return jsonify({"success": False, "message": "消息不能为空"}), 400
+        
+        # 验证Agent和令牌
+        agent_path = os.path.join('agents', f"{agent_id}.json")
+        if not os.path.exists(agent_path):
+            return jsonify({"success": False, "message": "Agent不存在"}), 404
+        
+        with open(agent_path, 'r', encoding='utf-8') as f:
+            agent_config = json.load(f)
+        
+        # 验证令牌（如果提供）
+        if token and "distributions" in agent_config:
+            valid_token = False
+            for dist in agent_config["distributions"]:
+                if dist.get("token") == token:
+                    valid_token = True
+                    
+                    # 更新使用计数
+                    dist["usage_count"] = dist.get("usage_count", 0) + 1
+                    break
+            
+            if not valid_token:
+                return jsonify({"success": False, "message": "访问令牌无效"}), 403
+                
+        # 更新Agent使用统计
+        if "stats" not in agent_config:
+            agent_config["stats"] = {}
+        
+        agent_config["stats"]["usage_count"] = agent_config["stats"].get("usage_count", 0) + 1
+        agent_config["stats"]["last_used"] = int(time.time())
+        
+        # 保存更新后���Agent配置
+        with open(agent_path, 'w', encoding='utf-8') as f:
+            json.dump(agent_config, f, ensure_ascii=False, indent=2)
+        
+        # 获取Agent关联的知识库和插件
+        knowledge_bases = agent_config.get('knowledge_bases', [])
+        plugins = agent_config.get('plugins', [])
+        
+        # 获取学科和指导者信息
+        subject = agent_config.get('subject', agent_config.get('name', '通用学科'))
+        instructor = agent_config.get('instructor', '教师')
+        
+        # 创建Generator实例，传入学科和指导者信息
+        from modules.knowledge_base.generator import Generator
+        generator = Generator(subject=subject, instructor=instructor)
+        
+        # 检测需要使用的插件
+        suggested_plugins = []
+            
+        # 检测是否需要代码执行插件
+        if 'code' in plugins and ('代码' in message or 'python' in message.lower() or '编程' in message or 'code' in message.lower() or 'program' in message.lower()):
+            suggested_plugins.append('code')
+                
+        # 检测是否需要3D可视化插件
+        if 'visualization' in plugins and ('3d' in message.lower() or '可视化' in message or '图形' in message):
+            suggested_plugins.append('visualization')
+                
+        # 检测是否需要思维导图插件
+        if 'mindmap' in plugins and ('思维导图' in message or 'mindmap' in message.lower()):
+            suggested_plugins.append('mindmap')
+        
+        # 检查是否有配置知识库
+        if not knowledge_bases:
+            # 没有知识库，直接使用模型进行回答
+            print(f"\n=== 处理查询: {message} (无知识库) ===")
+            
+            # 使用空的文档列表调用生成器进行回答
+            final_response = ""
+            for chunk in generator.generate_stream(message, []):
+                if isinstance(chunk, dict):
+                    continue  # 跳过处理数据
+                final_response += chunk
+            
+            # 返回生成的回答
+            return jsonify({
+                "success": True,
+                "message": final_response,
+                "tools": suggested_plugins
+            })
+        
+        # 有知识库配置，执行知识库查询流程
+        try:
+            # 导入RAG系统组件
+            from modules.knowledge_base.retriever import Retriever
+            from modules.knowledge_base.reranker import Reranker
+            
+            retriever = Retriever()
+            reranker = Reranker()
+            
+            # 构建工具定义 - 将所有知识库作为工具
+            tools = []
+            
+            # 创建工具名称到索引的映射
+            tool_to_index = {}
+            
+            for i, index in enumerate(knowledge_bases):
+                display_name = index[4:] if index.startswith('rag_') else index
+                
+                # 判断是否是视频知识库
+                is_video = "视频" in display_name or "video" in display_name.lower()
+                
+                # 根据内容类型生成适当的工具名称
+                if is_video:
+                    tool_name = f"video_knowledge_base_{i+1}"
+                    description = f"在'{display_name}'视频知识库中搜索，返回带时间戳的视频链接。适用于需要视频讲解的问题。"
+                else:
+                    tool_name = f"knowledge_base_{i+1}"
+                    description = f"在'{display_name}'知识库中搜索专业知识、概念和原理。适用于需要文本说明的问题。"
+                
+                # 添加工具名到索引的映射
+                tool_to_index[tool_name] = index
+                
+                tools.append({
+                    "type": "function",
+                    "function": {
+                        "name": tool_name,
+                        "description": description,
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "keywords": {
+                                    "type": "array",
+                                    "items": {"type": "string"},
+                                    "description": "搜索的关键词列表"
+                                }
+                            },
+                            "required": ["keywords"],
+                            "additionalProperties": False
+                        },
+                        "strict": True
+                    }
+                })
+            
+            # 第一阶段：工具选择决策
+            print(f"\n=== 处理查询: {message} ===")
+            tool_calls = generator.extract_keywords_with_tools(message, tools)
+            
+            # 如果不需要调用工具，直接回答
+            if not tool_calls:
+                print("未检测到需要使用知识库，直接回答")
+                final_response = ""
+                for chunk in generator.generate_stream(message, []):
+                    if isinstance(chunk, dict):
+                        continue  # 跳过处理数据
+                    final_response += chunk
+                
+                return jsonify({
+                    "success": True,
+                    "message": final_response,
+                    "tools": suggested_plugins
+                })
+            
+            # 收集来自工具执行的所有文档
+            all_docs = []
+            
+            # 执行每个工具调用
+            for tool_call in tool_calls:
+                try:
+                    tool_name = tool_call["function"]["name"]
+                    actual_index = tool_to_index.get(tool_name)
+                    
+                    if not actual_index:
+                        print(f"找不到工具名称 '{tool_name}' 对应的索引")
+                        continue
+                    
+                    print(f"\n执行工具 '{tool_name}' -> 使用索引 '{actual_index}'")
+                    
+                    arguments = json.loads(tool_call["function"]["arguments"])
+                    keywords = " ".join(arguments.get("keywords", []))
+                    
+                    if not keywords:
+                        print("没有提供关键词，跳过检索")
+                        continue
+                    
+                    print(f"检索关键词: {keywords}")
+                    
+                    # 执行检索
+                    retrieved_docs, _ = retriever.retrieve(keywords, specific_index=actual_index)
+                    print(f"检索到 {len(retrieved_docs)} 个文档")
+                    
+                    # 重排序文档
+                    reranked_docs = reranker.rerank(message, retrieved_docs, actual_index)
+                    print(f"重排序完成，排序后有 {len(reranked_docs)} 个文档")
+                    
+                    # 添加结果
+                    all_docs.extend(reranked_docs)
+                    
+                except Exception as e:
+                    print(f"执行工具 '{tool_call.get('function', {}).get('name', '未知')}' 调用时出错: {str(e)}")
+                    import traceback
+                    traceback.print_exc()
+            
+            # 如果没有检索到任何文档，直接回答
+            if not all_docs:
+                print("未检索到任何相关文档，直接回答")
+                final_response = ""
+                for chunk in generator.generate_stream(message, []):
+                    if isinstance(chunk, dict):
+                        continue  # 跳过处理数据
+                    final_response += chunk
+                
+                return jsonify({
+                    "success": True,
+                    "message": final_response,
+                    "tools": suggested_plugins
+                })
+            
+            # 按相关性排序
+            all_docs.sort(key=lambda x: x.get('rerank_score', 0), reverse=True)
+            print(f"\n最终收集到 {len(all_docs)} 个文档用于生成回答")
+            
+            # 提取参考信息
+            references = []
+            for i, doc in enumerate(all_docs[:3], 1):  # 只展示前3个参考来源
+                file_name = doc['metadata'].get('file_name', '未知文件')
+                content = doc['content']
+                
+                # 提取大约前100字符作为摘要
+                summary = content[:100] + ('...' if len(content) > 100 else '')
+                
+                references.append({
+                    'index': i,
+                    'file_name': file_name,
+                    'content': content,
+                    'summary': summary
+                })
+            
+            # 第二阶段：生成最终答案
+            final_response = ""
+            for chunk in generator.generate_stream(message, all_docs):
+                if isinstance(chunk, dict):
+                    continue  # 跳过处理数据
+                final_response += chunk
+            
+            # 构建回复
+            return jsonify({
+                "success": True,
+                "message": final_response,
+                "tools": suggested_plugins,
+                "references": references
+            })
+            
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
+            return jsonify({
+                "success": False, 
+                "message": f"处理查询时出错: {str(e)}"
+            }), 500
+            
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({"success": False, "message": str(e)}), 500
+
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=5000)

config.py

@@ -0,0 +1,23 @@
+# config.py
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# API keys
+API_KEY = os.getenv("API_KEY")
+BASE_URL = os.getenv("BASE_URL")
+STREAM_API_KEY = os.getenv("STREAM_API_KEY")
+STREAM_BASE_URL = os.getenv("STREAM_BASE_URL")
+STREAM_MODEL = os.getenv("STREAM_MODEL")
+DEFAULT_MODEL = os.getenv("DEFAULT_MODEL")
+OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+
+# Knowledge base configuration
+EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL", "BAAI/bge-m3")
+RERANK_MODEL = os.getenv("RERANK_MODEL", "BAAI/bge-reranker-v2-m3")
+
+# System configuration
+UPLOAD_FOLDER = "uploads"
+AGENTS_FOLDER = "agents"
+MAX_CONTENT_LENGTH = 16 * 1024 * 1024  # 16MB

modules/agent_builder/routes.py

@@ -0,0 +1,504 @@
+# modules/agent_builder/routes.py
+from flask import Blueprint, request, jsonify
+import os
+import json
+import time
+import uuid
+import requests
+from config import STREAM_API_KEY, STREAM_BASE_URL, DEFAULT_MODEL
+
+agent_builder_bp = Blueprint('agent_builder', __name__)
+
+# 确保Agent存储目录存在
+AGENTS_DIR = 'agents'
+os.makedirs(AGENTS_DIR, exist_ok=True)
+
+@agent_builder_bp.route('/create', methods=['POST'])
+def create_agent():
+    """创建新的Agent"""
+    try:
+        data = request.json
+        name = data.get('name')
+        description = data.get('description', '')
+        subject = data.get('subject', name)  # 默认使用名称作为学科
+        instructor = data.get('instructor', '教师')  # 默认使用教师作为指导者
+        plugins = data.get('plugins', [])
+        knowledge_bases = data.get('knowledge_bases', [])
+        workflow = data.get('workflow')
+        
+        if not name:
+            return jsonify({
+                "success": False,
+                "message": "Agent名称不能为空"
+            }), 400
+        
+        # 创建Agent ID
+        agent_id = f"agent_{uuid.uuid4().hex[:8]}_{int(time.time())}"
+        
+        # 构建Agent配置
+        agent_config = {
+            "id": agent_id,
+            "name": name,
+            "description": description,
+            "subject": subject,  # 添加学科
+            "instructor": instructor,  # 添加指导者
+            "created_at": int(time.time()),
+            "plugins": plugins,
+            "knowledge_bases": knowledge_bases,
+            "workflow": workflow or {
+                "nodes": [],
+                "edges": []
+            },
+            "distributions": [],
+            "stats": {
+                "usage_count": 0,
+                "last_used": None
+            }
+        }
+        
+        # 保存Agent配置
+        with open(os.path.join(AGENTS_DIR, f"{agent_id}.json"), 'w', encoding='utf-8') as f:
+            json.dump(agent_config, f, ensure_ascii=False, indent=2)
+        
+        return jsonify({
+            "success": True,
+            "agent_id": agent_id,
+            "message": f"Agent '{name}' 创建成功"
+        })
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({
+            "success": False,
+            "message": str(e)
+        }), 500
+
+@agent_builder_bp.route('/list', methods=['GET'])
+def list_agents():
+    """获取所有Agent列表"""
+    try:
+        agents = []
+        
+        for filename in os.listdir(AGENTS_DIR):
+            if filename.endswith('.json'):
+                with open(os.path.join(AGENTS_DIR, filename), 'r', encoding='utf-8') as f:
+                    agent_config = json.load(f)
+                    
+                    # 简化版本，只返回关键信息
+                    agents.append({
+                        "id": agent_config.get("id"),
+                        "name": agent_config.get("name"),
+                        "description": agent_config.get("description"),
+                        "subject": agent_config.get("subject", agent_config.get("name")),
+                        "instructor": agent_config.get("instructor", "教师"),
+                        "created_at": agent_config.get("created_at"),
+                        "plugins": agent_config.get("plugins", []),
+                        "knowledge_bases": agent_config.get("knowledge_bases", []),
+                        "usage_count": agent_config.get("stats", {}).get("usage_count", 0),
+                        "distribution_count": len(agent_config.get("distributions", []))
+                    })
+        
+        # 按创建时间排序
+        agents.sort(key=lambda x: x.get("created_at", 0), reverse=True)
+        
+        return jsonify({
+            "success": True,
+            "agents": agents
+        })
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({
+            "success": False,
+            "message": str(e)
+        }), 500
+
+@agent_builder_bp.route('/<agent_id>', methods=['GET'])
+def get_agent(agent_id):
+    """获取特定Agent的配置"""
+    try:
+        agent_path = os.path.join(AGENTS_DIR, f"{agent_id}.json")
+        
+        if not os.path.exists(agent_path):
+            return jsonify({
+                "success": False,
+                "message": "Agent不存在"
+            }), 404
+        
+        with open(agent_path, 'r', encoding='utf-8') as f:
+            agent_config = json.load(f)
+        
+        return jsonify({
+            "success": True,
+            "agent": agent_config
+        })
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({
+            "success": False,
+            "message": str(e)
+        }), 500
+
+@agent_builder_bp.route('/<agent_id>', methods=['PUT'])
+def update_agent(agent_id):
+    """更新Agent配置"""
+    try:
+        data = request.json
+        agent_path = os.path.join(AGENTS_DIR, f"{agent_id}.json")
+        
+        if not os.path.exists(agent_path):
+            return jsonify({
+                "success": False,
+                "message": "Agent不存在"
+            }), 404
+        
+        # 读取现有配置
+        with open(agent_path, 'r', encoding='utf-8') as f:
+            agent_config = json.load(f)
+        
+        # 更新允许的字段
+        if 'name' in data:
+            agent_config['name'] = data['name']
+        
+        if 'description' in data:
+            agent_config['description'] = data['description']
+        
+        if 'plugins' in data:
+            agent_config['plugins'] = data['plugins']
+        
+        if 'knowledge_bases' in data:
+            agent_config['knowledge_bases'] = data['knowledge_bases']
+        
+        if 'workflow' in data:
+            agent_config['workflow'] = data['workflow']
+        
+        # 添加更新时间
+        agent_config['updated_at'] = int(time.time())
+        
+        # 保存更新后的配置
+        with open(agent_path, 'w', encoding='utf-8') as f:
+            json.dump(agent_config, f, ensure_ascii=False, indent=2)
+        
+        return jsonify({
+            "success": True,
+            "message": "Agent更新成功"
+        })
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({
+            "success": False,
+            "message": str(e)
+        }), 500
+
+@agent_builder_bp.route('/<agent_id>', methods=['DELETE'])
+def delete_agent(agent_id):
+    """删除Agent"""
+    try:
+        agent_path = os.path.join(AGENTS_DIR, f"{agent_id}.json")
+        
+        if not os.path.exists(agent_path):
+            return jsonify({
+                "success": False,
+                "message": "Agent不存在"
+            }), 404
+        
+        # 删除Agent配置文件
+        os.remove(agent_path)
+        
+        return jsonify({
+            "success": True,
+            "message": "Agent删除成功"
+        })
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({
+            "success": False,
+            "message": str(e)
+        }), 500
+
+@agent_builder_bp.route('/<agent_id>/distribute', methods=['POST'])
+def distribute_agent(agent_id):
+    """为Agent创建分发链接"""
+    try:
+        data = request.json
+        expires_in = data.get('expires_in', 0)  # 0表示永不过期
+        
+        agent_path = os.path.join(AGENTS_DIR, f"{agent_id}.json")
+        
+        if not os.path.exists(agent_path):
+            return jsonify({
+                "success": False,
+                "message": "Agent不存在"
+            }), 404
+        
+        # 读取Agent配置
+        with open(agent_path, 'r', encoding='utf-8') as f:
+            agent_config = json.load(f)
+        
+        # 创建访问令牌
+        token = uuid.uuid4().hex
+        
+        # 计算过期时间
+        expiry = int(time.time() + expires_in) if expires_in > 0 else 0
+        
+        # 创建分发记录
+        distribution = {
+            "id": f"dist_{uuid.uuid4().hex[:6]}",
+            "created_at": int(time.time()),
+            "token": token,
+            "expires_at": expiry,
+            "usage_count": 0
+        }
+        
+        # 更新Agent配置
+        if "distributions" not in agent_config:
+            agent_config["distributions"] = []
+            
+        agent_config["distributions"].append(distribution)
+        
+        # 保存更新后的配置
+        with open(agent_path, 'w', encoding='utf-8') as f:
+            json.dump(agent_config, f, ensure_ascii=False, indent=2)
+        
+        # 构建访问链接
+        access_link = f"/student/{agent_id}?token={token}"
+        
+        return jsonify({
+            "success": True,
+            "distribution": {
+                "id": distribution["id"],
+                "link": access_link,
+                "token": token,
+                "expires_at": expiry
+            },
+            "message": "分发链接创建成功"
+        })
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({
+            "success": False,
+            "message": str(e)
+        }), 500
+
+@agent_builder_bp.route('/ai-assist', methods=['POST'])
+def ai_assisted_workflow():
+    """使用AI辅助Agent工作流编排"""
+    try:
+        data = request.json
+        description = data.get('description', '')
+        subject = data.get('subject', '通用学科')
+        knowledge_bases = data.get('knowledge_bases', [])
+        plugins = data.get('plugins', [])
+        
+        if not description:
+            return jsonify({
+                "success": False,
+                "message": "请提供Agent描述"
+            }), 400
+            
+        # 获取所有可用的知识库
+        available_knowledge_bases = []
+        try:
+            # 获取知识库列表的API调用
+            kb_response = requests.get("http://localhost:5000/api/knowledge")
+            if kb_response.status_code == 200:
+                kb_data = kb_response.json()
+                if kb_data.get("success"):
+                    for kb in kb_data.get("data", []):
+                        available_knowledge_bases.append(kb["id"])
+        except:
+            # 如果API调用失败，使用默认值
+            pass
+            
+        # 可用的插件
+        available_plugins = ["code", "visualization", "mindmap"]
+        
+        # 构建提示
+        system_prompt = """你是一个专业的AI工作流设计师。你需要根据用户描述，设计一个适合教育场景的Agent工作流。
+        你不仅要设计工作流结构，还要推荐合适的知识库和插件。请确保工作流逻辑合理，能够满足用户的需求。
+        
+        工作流应包含以下类型的节点：
+        1. 意图识别：识别用户输入的意图
+        2. 知识库查询：从指定知识库中检索信息
+        3. 插件调用：调用特定插件（如代码执行、3D可视化或思维导图）
+        4. 回复生成：生成最终回复
+        
+        用户当前选择的知识库：{knowledge_bases}
+        系统中可用的知识库有：{available_knowledge_bases}
+        
+        用户当前选择的插件：{plugins}
+        系统中可用的插件有：{available_plugins}
+        
+        这个Agent的主题领域是：{subject}
+        
+        重要：根据Agent描述，推荐最合适的知识库和插件。在推荐时，只能使用系统中真实可用的知识库和插件。
+        
+        请返回三部分内容：
+        1. 推荐的知识库列表（只能从可用知识库中选择）
+        2. 推荐的插件列表（只能从可用插件中选择）
+        3. 完整的工作流JSON结构
+        
+        JSON格式示例：
+        {{
+          "recommended_knowledge_bases": ["rag_knowledge1", "rag_knowledge2"],
+          "recommended_plugins": ["code", "visualization"],
+          "workflow": {{
+            "nodes": [
+              {{ "id": "node1", "type": "intent_recognition", "data": {{ "name": "意图识别" }} }},
+              {{ "id": "node2", "type": "knowledge_query", "data": {{ "name": "知识库查询", "knowledge_base_id": "rag_knowledge1" }} }},
+              {{ "id": "node3", "type": "plugin_call", "data": {{ "name": "调用代码执行插件", "plugin_id": "code" }} }},
+              {{ "id": "node4", "type": "generate_response", "data": {{ "name": "生成回复" }} }}
+            ],
+            "edges": [
+              {{ "id": "edge1", "source": "node1", "target": "node2", "condition": "需要知识" }},
+              {{ "id": "edge2", "source": "node1", "target": "node3", "condition": "需要代码执行" }},
+              {{ "id": "edge3", "source": "node2", "target": "node4" }},
+              {{ "id": "edge4", "source": "node3", "target": "node4" }}
+            ]
+          }}
+        }}
+        """
+        
+        system_prompt = system_prompt.format(
+            knowledge_bases=", ".join(knowledge_bases) if knowledge_bases else "无",
+            available_knowledge_bases=", ".join(available_knowledge_bases) if available_knowledge_bases else "无可用知识库",
+            plugins=", ".join(plugins) if plugins else "无",
+            available_plugins=", ".join(available_plugins),
+            subject=subject
+        )
+        
+        # 使用流式API
+        try:
+            headers = {
+                "Authorization": f"Bearer {STREAM_API_KEY}",
+                "Content-Type": "application/json"
+            }
+            
+            response = requests.post(
+                f"{STREAM_BASE_URL}/chat/completions",
+                headers=headers,
+                json={
+                    "model": DEFAULT_MODEL,
+                    "messages": [
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": f"请为以下描述的教育Agent设计工作流并推荐知识库和插件：\n\n{description}"}
+                    ]
+                }
+            )
+            
+            if response.status_code != 200:
+                return jsonify({
+                    "success": False,
+                    "message": f"Error code: {response.status_code} - {response.text}",
+                    "workflow": create_default_workflow(),
+                    "recommended_knowledge_bases": [],
+                    "recommended_plugins": []
+                }), 200  # 返回200但��含错误信息和备用工作流
+            
+            result = response.json()
+            content = result['choices'][0]['message']['content']
+            
+        except Exception as api_error:
+            return jsonify({
+                "success": False,
+                "message": f"无法连接到AI模型服务: {str(api_error)}",
+                "workflow": create_default_workflow(),
+                "recommended_knowledge_bases": [],
+                "recommended_plugins": []
+            }), 200
+        
+        # 查找JSON部分
+        import re
+        json_match = re.search(r'```json\n([\s\S]*?)\n```', content)
+        
+        if json_match:
+            workflow_json = json_match.group(1)
+        else:
+            # 尝试直接解析整个内容
+            workflow_json = content
+        
+        # 解析JSON
+        try:
+            result_data = json.loads(workflow_json)
+        except:
+            # 如果解析失败，使用正则表达式清理
+            workflow_json = re.sub(r'```json\n|\n```', '', content)
+            try:
+                result_data = json.loads(workflow_json)
+            except:
+                # 如果仍然解析失败，提取标准的JSON结构 { ... }
+                import re
+                json_patterns = re.findall(r'\{[\s\S]*?\}', content)
+                if json_patterns:
+                    try:
+                        # 尝试解析最长的JSON结构
+                        longest_json = max(json_patterns, key=len)
+                        result_data = json.loads(longest_json)
+                    except:
+                        # 仍然失败，返回默认值
+                        return jsonify({
+                            "success": True,
+                            "message": "使用默认工作流（AI生成的JSON无效）",
+                            "workflow": create_default_workflow(),
+                            "recommended_knowledge_bases": [],
+                            "recommended_plugins": []
+                        })
+                else:
+                    # 没有找到有效的JSON结构
+                    return jsonify({
+                        "success": True,
+                        "message": "使用默认工作流（未找到JSON结构）",
+                        "workflow": create_default_workflow(),
+                        "recommended_knowledge_bases": [],
+                        "recommended_plugins": []
+                    })
+        
+        # 提取推荐的知识库和插件
+        recommended_knowledge_bases = result_data.get("recommended_knowledge_bases", [])
+        recommended_plugins = result_data.get("recommended_plugins", [])
+        workflow = result_data.get("workflow", create_default_workflow())
+        
+        # 验证推荐的知识库都存在
+        valid_knowledge_bases = []
+        for kb in recommended_knowledge_bases:
+            if kb in available_knowledge_bases:
+                valid_knowledge_bases.append(kb)
+        
+        # 验证推荐的插件都存在
+        valid_plugins = []
+        for plugin in recommended_plugins:
+            if plugin in available_plugins:
+                valid_plugins.append(plugin)
+        
+        return jsonify({
+            "success": True,
+            "workflow": workflow,
+            "recommended_knowledge_bases": valid_knowledge_bases,
+            "recommended_plugins": valid_plugins,
+            "message": "已成功创建工作流"
+        })
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({
+            "success": False, 
+            "message": str(e)
+        }), 500
+
+def create_default_workflow():
+    """创建一个默认的空工作流"""
+    return {
+        "nodes": [],
+        "edges": []
+    }

modules/code_executor/routes.py

@@ -0,0 +1,356 @@
+# modules/code_executor/routes.py
+from flask import Blueprint, request, jsonify
+import sys
+import io
+import threading
+import queue
+import time
+import traceback
+import os
+import re
+from openai import OpenAI
+from config import API_KEY, BASE_URL, OPENAI_MODEL
+
+code_executor_bp = Blueprint('code_executor', __name__)
+
+# 创建OpenAI客户端
+client = OpenAI(
+    api_key=API_KEY,
+    base_url=BASE_URL
+)
+
+# 执行上下文存储
+execution_contexts = {}
+
+class CustomStdin:
+    def __init__(self, input_queue):
+        self.input_queue = input_queue
+        self.buffer = ""
+    
+    def readline(self):
+        if not self.buffer:
+            self.buffer = self.input_queue.get() + "\n"
+        
+        result = self.buffer
+        self.buffer = ""
+        return result
+
+class InteractiveExecution:
+    """管理Python代码的交互式执行"""
+    def __init__(self, code):
+        self.code = code
+        self.context_id = str(time.time())
+        self.is_complete = False
+        self.is_waiting_for_input = False
+        self.stdout_buffer = io.StringIO()
+        self.last_read_position = 0
+        self.input_queue = queue.Queue()
+        self.error = None
+        self.thread = None
+        self.should_terminate = False
+    
+    def run(self):
+        """在单独的线程中启动执行"""
+        self.thread = threading.Thread(target=self._execute)
+        self.thread.daemon = True
+        self.thread.start()
+        
+        # 给执行一点时间开始
+        time.sleep(0.1)
+        return self.context_id
+    
+    def _execute(self):
+        """执行代码，处理标准输入输出"""
+        try:
+            # 保存原始的stdin/stdout
+            orig_stdin = sys.stdin
+            orig_stdout = sys.stdout
+            
+            # 创建自定义stdin
+            custom_stdin = CustomStdin(self.input_queue)
+            
+            # 重定向stdin和stdout
+            sys.stdin = custom_stdin
+            sys.stdout = self.stdout_buffer
+            
+            try:
+                # 检查终止的函数
+                self._last_check_time = 0
+                
+                def check_termination():
+                    if self.should_terminate:
+                        raise KeyboardInterrupt("Execution terminated by user")
+                
+                # 设置一个模拟__main__模块的命名空间
+                shared_namespace = {
+                    "__builtins__": __builtins__,
+                    "_check_termination": check_termination,
+                    "time": time, 
+                    "__name__": "__main__"
+                }
+                
+                # 在这个命名空间中执行用户代码
+                try:
+                    exec(self.code, shared_namespace)
+                except KeyboardInterrupt:
+                    print("\nExecution terminated by user")
+                
+            except Exception as e:
+                self.error = {
+                    "error": str(e),
+                    "traceback": traceback.format_exc()
+                }
+            
+            finally:
+                # 恢复原始stdin/stdout
+                sys.stdin = orig_stdin
+                sys.stdout = orig_stdout
+                
+                # 标记执行完成
+                self.is_complete = True
+                
+        except Exception as e:
+            self.error = {
+                "error": str(e),
+                "traceback": traceback.format_exc()
+            }
+            self.is_complete = True
+    
+    def terminate(self):
+        """终止执行"""
+        self.should_terminate = True
+        
+        # 如果在等待输入，放入一些内容以解除阻塞
+        if self.is_waiting_for_input:
+            self.input_queue.put("\n")
+        
+        # 给执行一点时间终止
+        time.sleep(0.2)
+        
+        # 标记为完成
+        self.is_complete = True
+        
+        return True
+    
+    def provide_input(self, user_input):
+        """为运行的代码提供输入"""
+        self.input_queue.put(user_input)
+        self.is_waiting_for_input = False
+        return True
+    
+    def get_output(self):
+        """获取stdout缓冲区的当前内容"""
+        output = self.stdout_buffer.getvalue()
+        return output
+        
+    def get_new_output(self):
+        """只获取自上次读取以来的新输出"""
+        current_value = self.stdout_buffer.getvalue()
+        if self.last_read_position < len(current_value):
+            new_output = current_value[self.last_read_position:]
+            self.last_read_position = len(current_value)
+            return new_output
+        return ""
+
+@code_executor_bp.route('/generate', methods=['POST'])
+def generate_code():
+    """使用AI生成Python代码"""
+    try:
+        prompt = request.json.get('prompt')
+        if not prompt:
+            return jsonify({
+                "success": False,
+                "error": "No prompt provided"
+            })
+
+        # 构建带有适当上下文的提示
+        full_prompt = f"""You are a Python programming assistant. Generate Python code based on this requirement:
+        {prompt}
+        
+        Provide only the Python code without any explanation or markdown formatting."""
+
+        # 调用OpenAI API
+        response = client.chat.completions.create(
+            model=OPENAI_MODEL,
+            messages=[{"role": "user", "content": full_prompt}]
+        )
+
+        # 提取和清理代码
+        code = response.choices[0].message.content.strip()
+        
+        # 删除Markdown代码块标记（如果存在）
+        code = re.sub(r'```python\n', '', code)
+        code = re.sub(r'```', '', code)
+
+        return jsonify({
+            "success": True,
+            "code": code
+        })
+
+    except Exception as e:
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        })
+
+@code_executor_bp.route('/execute', methods=['POST'])
+def execute_code():
+    """执行Python代码"""
+    try:
+        code = request.json.get('code')
+        if not code:
+            return jsonify({
+                "success": False,
+                "error": "No code provided"
+            })
+
+        # 创建并启动执行
+        execution = InteractiveExecution(code)
+        context_id = execution.run()
+        
+        # 存储在全局上下文中
+        execution_contexts[context_id] = execution
+        
+        # 检查初始状态
+        if execution.error:
+            # 执行立即失败
+            error_info = execution.error
+            del execution_contexts[context_id]
+            
+            return jsonify({
+                "success": False,
+                "error": error_info["error"],
+                "traceback": error_info["traceback"]
+            })
+        
+        # 获取初始输出
+        output = execution.get_output()
+        # 更新上次读取位置以标记此输出为已读
+        execution.last_read_position = len(output)
+        
+        # 检查是否命中input()调用或完成执行
+        if execution.is_complete:
+            # 执行完成，不需要输入
+            del execution_contexts[context_id]
+            
+            return jsonify({
+                "success": True,
+                "output": output,
+                "needsInput": False
+            })
+        else:
+            # 假设我们正在等待输入
+            execution.is_waiting_for_input = True
+            
+            return jsonify({
+                "success": True,
+                "output": output,
+                "needsInput": True,
+                "context_id": context_id
+            })
+
+    except Exception as e:
+        return jsonify({
+            "success": False,
+            "error": str(e),
+            "traceback": traceback.format_exc()
+        })
+
+@code_executor_bp.route('/input', methods=['POST'])
+def provide_input():
+    """为正在执行的代码提供输入"""
+    try:
+        user_input = request.json.get('input', '')
+        context_id = request.json.get('context_id')
+        
+        if not context_id or context_id not in execution_contexts:
+            return jsonify({
+                "success": False,
+                "error": "Invalid or expired execution context"
+            })
+        
+        execution = execution_contexts[context_id]
+        
+        # 提供输入
+        execution.provide_input(user_input)
+        
+        # 给一点时间处理
+        time.sleep(0.1)
+        
+        # 获取输入后的新输出
+        new_output = execution.get_new_output()
+        
+        # 检查执行状态
+        if execution.is_complete:
+            # 执行已完成
+            if execution.error:
+                # 有错误
+                error_info = execution.error
+                del execution_contexts[context_id]
+                
+                return jsonify({
+                    "success": False,
+                    "error": error_info["error"],
+                    "traceback": error_info["traceback"]
+                })
+            else:
+                # 干净执行
+                del execution_contexts[context_id]
+                
+                return jsonify({
+                    "success": True,
+                    "output": new_output,
+                    "needsInput": False
+                })
+        else:
+            # 执行仍在运行，假设我们需要更多输入
+            execution.is_waiting_for_input = True
+            
+            return jsonify({
+                "success": True,
+                "output": new_output,
+                "needsInput": True
+            })
+            
+    except Exception as e:
+        return jsonify({
+            "success": False,
+            "error": str(e),
+            "traceback": traceback.format_exc()
+        })
+
+@code_executor_bp.route('/stop', methods=['POST'])
+def stop_execution():
+    """停止执行"""
+    try:
+        context_id = request.json.get('context_id')
+        
+        if not context_id or context_id not in execution_contexts:
+            return jsonify({
+                "success": False,
+                "error": "Invalid or expired execution context"
+            })
+        
+        execution = execution_contexts[context_id]
+        
+        # 终止执行
+        execution.terminate()
+        
+        # 获取最终输出
+        output = execution.get_output()
+        
+        # 清理
+        del execution_contexts[context_id]
+        
+        return jsonify({
+            "success": True,
+            "output": output,
+            "message": "Execution terminated"
+        })
+            
+    except Exception as e:
+        return jsonify({
+            "success": False,
+            "error": str(e),
+            "traceback": traceback.format_exc()
+        })

modules/knowledge_base/generator.py

@@ -0,0 +1,396 @@
+# modules/knowledge_base/generator.py
+from typing import List, Dict, Generator, Union, Optional, Any
+import requests
+import os
+import json
+import time
+import re
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Generator:
+    def __init__(self, subject="", instructor=""):
+        # Set defaults if not provided
+        self.subject = subject or "通用学科"
+        self.instructor = instructor or "教师"
+        
+        # 基础API配置
+        self.api_key = os.getenv("API_KEY")
+        self.api_base = os.getenv("BASE_URL")
+        
+        # 流式文本问答配置
+        self.stream_api_key = os.getenv("STREAM_API_KEY")
+        self.stream_api_base = os.getenv("STREAM_BASE_URL")
+        self.stream_model = os.getenv("STREAM_MODEL")
+        
+        # 通用提示词模板 - 填充主题和讲师信息
+        self.system_prompt = self.get_system_prompt_template().format(
+            subject=self.subject,
+            instructor=self.instructor
+        )
+
+    def get_system_prompt_template(self):
+        """返回可定制的系统提示词模板"""
+        return """<system>
+你是一位{subject}课程的智能助教，由{instructor}指导开发。你的目标是帮助学生理解和掌握{subject}课程的关键概念、原理和方法。
+
+<knowledge_base>
+你拥有《{subject}》课程的专业知识库，包含教材内容、课件、习题解析等材料。当回答问题时，你应该优先使用知识库中检索到的相关内容，而不是依赖你的通用知识。
+</knowledge_base>
+
+<role_definition>
+作为{subject}助教，你应该:
+1. 用专业且易于理解的方式解释复杂概念
+2. 提供准确的技术信息和计算示例
+3. 在适当时使用比喻或类比帮助理解
+4. 引导学生思考而不是直接给出所有答案
+5. ⁠提供进一步学习的建议和资源
+</role_definition>
+
+<answering_guidelines>
+当回答问题时，请遵循以下原则：
+1. 先从知识库中检索与问题最相关的内容
+2. 将检索结果整合成连贯、清晰的回答
+3. 保持学术严谨性，确保概念解释和计算过程准确无误
+4. 使用专业术语的同时，确保解释足够通俗易懂
+5. 回答问题时注明知识来源，例如"根据教材第X章..."
+6. 当遇到计算题时，展示完整的计算步骤和思路
+7. 当知识库中没有直接相关内容时，明确告知学生并提供基于可靠原理的解答
+8. 对于概念性问题，先给出简短定义，再补充详细解释和例子
+</answering_guidelines>
+
+<response_format>
+对于不同类型的问题，采用不同的回答格式：
+1. 概念解释类问题：
+   - 先给出简明定义
+   - 提供详细解释
+   - 举例说明
+   - 补充相关知识点连接
+2. 计算类问题：
+   - 明确列出已知条件和所求内容
+   - 说明解题思路和所用公式
+   - 展示详细计算步骤
+   - 给出最终答案并解释其含义
+3. 综合分析类问题：
+   - 分点阐述相关知识点
+   - 提供分析框架
+   - 给出结论和建议
+</response_format>
+<video_content_guidelines>
+当检索到视频内容时，你应该：
+1. 明确告知用户你找到了相关视频资源
+2. 提供视频链接并确保包含时间戳
+3. 简要描述视频内容和主要学习点
+4. 建议用户观看视频以获得可视化理解
+5. 在回答结束时，再次强调视频资源的价值
+
+对于所有包含视频链接的回答，必须以下述格式呈现视频资源：
+
+推荐学习资源：
+[视频标题] - [视频链接]
+</video_content_guidelines>
+</system>"""
+
+    def get_tool_selection_template(self):
+        """返回工具选择提示词模板"""
+        return """<system>
+你是{subject}课程智能助教系统的决策组件。你的唯一任务是判断用户问题类型并决定是否调用知识库工具，以及提取精准的搜索关键词。
+
+<decision_guidelines>
+对于所有涉及{subject}专业知识的问题，必须调用至少一个知识库工具。系统依赖这些知识库提供准确信息，而不是依赖模型的通用知识。
+
+判断标准：
+1. 所有涉及课程概念、原理、计算方法的问题 → 必须调用相关知识库
+2. 所有需要专业解释或例子的问题 → 必须调用相关知识库
+3. 所有学习指导或复习相关的问题 → 必须调用相关知识库
+4. 仅对于纯粹的问候语或与课程无关的闲聊 → 不调用任何工具
+
+当决定调用知识库时，提取的关键词必须满足以下条件：
+1. 准确反映问题的核心主题
+2. 包含{subject}相关的专业术语或技术名词
+3. 去除无关紧要的修饰词
+4. 每个关键词尽量简洁，优先使用专业术语
+5. 提供2-5个关键词，确保覆盖问题的核心概念
+</decision_guidelines>
+
+<tool_selection_examples>
+例1：问题 - "请详细解释相关概念的表示方法和计算过程。"
+判断：需要专业知识解释
+工具选择：教材知识库（包含基础概念和详细解释）
+关键词：["表示方法", "计��过程"]
+
+例2：问题 - "这个概念的工作原理是什么？能给我一个直观的例子吗？"
+判断：需要专业知识解释，且需要直观演示
+工具选择：教材知识库（基础概念）和视频知识库（直观演示）
+关键词：["工作原理", "例子"]
+
+例3：问题 - "你好，今天天气怎么样？"
+判断：与课程无关的闲聊
+工具选择：不调用任何工具
+关键词：[]
+</tool_selection_examples>
+
+<video_knowledge_criteria>
+以下情况应优先选择视频知识库工具：
+1. 用户明确要求视频讲解或视频资料
+2. 问题涉及复杂的步骤或流程，可能需要可视化展示
+3. 问题关于动态过程的理解
+4. 问题涉及图形或结构的理解
+5. 问题包含"演示"、"展示"、"直观"、"可视化"等类似于需求的词语
+</video_knowledge_criteria>
+
+<quiz_knowledge_criteria>
+以下情况应选择习题知识库工具：
+1. 用户明确询问习题、例题或解题方法
+2. 问题是关于如何解决特定类型的问题
+3. 用户寻求考试或作业的帮助
+4. 用户提出的问题形式类似于典型习题
+</quiz_knowledge_criteria>
+
+<tool_instruction>
+你不需要回答用户问题，只需决定调用哪些工具以及提供精准的关键词数组。
+</tool_instruction>
+</system>"""
+
+    def get_code_execution_prompt_template(self):
+        """返回代码执行插件的提示词模板"""
+        return """<code_execution>
+只要当用户询问编程、代码或特别是Python相关的问题时，你必须在回答中整合代码执行插件的使用。
+
+使用代码执行插件的指南：
+1. 创建Python代码示例时，请使用正确的Markdown语法，用```python和```作为代码块的分隔符。
+2. 确保你的代码示例完整、可运行，并附有适当的注释。
+3. 在代码前后提供解释，帮助用户理解代码的功能和原理。
+4. 当代码与用户问题相关时，明确告知用户可以使用代码执行环境运行这段代码。
+5. 对于教学场景，考虑创建循序渐进的代码示例，让用户可以逐步学习和理解。
+
+示例回答格式：
+"这是一个[描述]的Python程序：
+
+```python
+# 你的完整、可运行的代码
+print('Hello, world!')
+```
+
+你可以通过点击'运行'按钮在代码执行环境中运行这段代码。
+如果你想修改代码，只需在编辑器中编辑并再次运行即可。"
+</code_execution>"""
+
+    def get_visualization_prompt_template(self):
+        """返回可视化插件的提示词模板"""
+        return """<visualization>
+当用户询问有关数学图形、函数、几何或需要3D可视化的内容时，你应该在回答中提供一个完整的Python函数来生成3D图形。
+
+使用3D可视化插件的指南：
+1. 你必须提供一个名为create_3d_plot的Python函数，该函数不接受任何参数。
+2. 这个函数应该导入必要的库（主要是numpy as np）。
+3. 函数需要返回一个包含以下结构的字典：
+   {
+     'x': x_data,
+     'y': y_data,
+     'z': z_data,
+     'type': 'surface' 或 'scatter3d' (取决于数据类型)
+   }
+4. 确保你的代码可以直接运行，无需额外修改。
+
+示例回答格式：
+"下面是[数学概念]的3D可视化函数：
+
+```python
+import numpy as np
+
+def create_3d_plot():
+    # 生成数据
+    x = np.linspace(-5, 5, 100)
+    y = np.linspace(-5, 5, 100)
+    X, Y = np.meshgrid(x, y)
+    Z = np.sin(np.sqrt(X**2 + Y**2))
+    
+    return {
+        'x': X.tolist(),
+        'y': Y.tolist(),
+        'z': Z.tolist(),
+        'type': 'surface'
+    }
+```
+
+这个函数创建了[概念描述]的3D图形，你可以观察[关键特征]。"
+</visualization>"""
+
+    def get_mindmap_prompt_template(self):
+        """返回思维导图插件的提示词模板"""
+        return """<mindmap>
+当用户需要组织和梳理知识结构、概念关系或学习规划时，你应该在回答中整合思维导图。
+
+使用思维导图的指南：
+1. 提供一个完整的思维导图结构，使用PlantUML格式。
+2. 使用@startmindmap和@endmindmap标记包裹内容。
+3. 使用星号(*)表示层级：*为中央主题，**为主要主题，***为子主题，****为叶子节点。
+4. 确保思维导图结构清晰、逻辑合理，能够帮助用户理解知识体系。
+
+示例格式：
+@startmindmap
+* 中心主题
+** 主要分支1
+*** 子主题1.1
+**** 叶子节点1.1.1
+*** 子主题1.2
+** 主要分支2
+*** 子主题2.1
+@endmindmap
+
+确保思维导图涵盖主题的关键概念和它们之间的关系，帮助用户建立完整的知识体系。
+</mindmap>"""
+
+    def extract_keywords_with_tools(self, question: str, tools: List[Dict]) -> List[Dict]:
+        """使用工具化架构分析问题，决定使用哪些知识库以及提取关键词"""
+        system_prompt = self.get_tool_selection_template().format(subject=self.subject)
+
+        headers = {
+            "Authorization": f"Bearer {self.stream_api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        response = requests.post(
+            f"{self.stream_api_base}/chat/completions",
+            headers=headers,
+            json={
+                "model": self.stream_model,
+                "messages": [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": question}
+                ],
+                "tools": tools,
+                "tool_choice": "auto"
+            }
+        )
+        
+        if response.status_code != 200:
+            raise Exception(f"工具调用出错: {response.text}")
+            
+        response_data = response.json()
+        message = response_data["choices"][0]["message"]
+        
+        # 如果模型决定调用工具
+        if "tool_calls" in message and message["tool_calls"]:
+            return message["tool_calls"]
+        else:
+            # 模型没有调用工具，返回空列表
+            return []
+        
+    def generate_stream(self, query: str, context_docs: List[Dict], process_data: Optional[Dict] = None) -> Generator[Union[str, Dict], None, None]:
+        """流式生成回答 - 用于所有类型的问答"""
+        start_time = time.time()
+        
+        # 构建带有引用标记的上下文
+        context_with_refs = []
+        
+        # 检查是否有图片URL
+        has_images = any(doc['metadata'].get('img_url', '') for doc in context_docs)
+        
+        # 检查查询是否与特定插件相关
+        is_code_related = any(kw in query.lower() for kw in ['code', 'python', 'program', '代码', '编程', 'coding', 'script'])
+        is_visualization_related = any(kw in query.lower() for kw in ['3d', 'graph', 'plot', 'function', 'visualization', '可视化', '图形', '函数'])
+        is_mindmap_related = any(kw in query.lower() for kw in ['mindmap', 'mind map', 'concept map', '思维导图', '概念图', '知识图'])
+        
+        # 处理每个文档
+        for i, doc in enumerate(context_docs, 1):
+            # 直接使用文件名作为来源
+            file_name = doc['metadata'].get('file_name', '未知文件')
+            img_url = doc['metadata'].get('img_url', '')
+            
+            # 构建文档内容，如果有图片URL则包含在内
+            content = doc['content']
+            if img_url:
+                content += f"\n[图片地址: {img_url}]"
+            
+            context_with_refs.append(f"[{i}] {content}\n来源：{file_name}")
+        
+        context = "\n\n".join(context_with_refs)
+        
+        # 增强系统提示词，根据查询内容添加插件特定提示
+        enhanced_system_prompt = self.system_prompt
+        
+        # 如果包含图片，添加图片处理相关指令
+        if has_images:
+            enhanced_system_prompt += """
+此外，如果参考内容中包含图片地址，请在回答中适当引用这些图片信息，并在回答的最后列出所有参考的图片来源。
+"""
+        
+        # 添加插件特定提示
+        if is_code_related:
+            enhanced_system_prompt += "\n\n" + self.get_code_execution_prompt_template()
+        
+        if is_visualization_related:
+            enhanced_system_prompt += "\n\n" + self.get_visualization_prompt_template()
+            
+        if is_mindmap_related:
+            enhanced_system_prompt += "\n\n" + self.get_mindmap_prompt_template()
+        
+        # 流式API
+        headers = {
+            "Authorization": f"Bearer {self.stream_api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        try:
+            response = requests.post(
+                f"{self.stream_api_base}/chat/completions",
+                headers=headers,
+                json={
+                    "model": self.stream_model,
+                    "messages": [
+                        {"role": "system", "content": enhanced_system_prompt},
+                        {"role": "user", "content": f"""
+参考内容：
+{context}
+
+问题：{query}
+
+请按照要求回答问题，包括引用标注和来源列表。
+
+如果在参考内容中找到视频资源，请使用以下格式标记视频链接：
+<video_link>视频链接</video_link>
+
+在回答结束时，请使用以下固定格式列出所有获取的参考内容作为参考来源：
+
+===参考来源开始===
+[1] 摘要内容，"文件名"
+[2] 摘要内容，"文件名"
+===参考来源结束===
+
+如果没有参考内容，则无需包含上述部分。
+"""}
+                    ],
+                    "stream": True
+                }
+            )
+            
+            if response.status_code != 200:
+                yield f"生成回答时出错: {response.text}"
+                return
+                
+            # 返回流式响应
+            for line in response.iter_lines():
+                if not line:
+                    continue
+                    
+                line_text = line.decode('utf-8')
+                if line_text.startswith('data: ') and line_text != 'data: [DONE]':
+                    try:
+                        json_str = line_text[6:]  # 移除 "data: " 前缀
+                        data = json.loads(json_str)
+                        content = data.get('choices', [{}])[0].get('delta', {}).get('content', '')
+                        if content:
+                            yield content
+                    except Exception as e:
+                        yield f"解析响应出错: {str(e)}"
+            
+            # 如果需要返回处理数据
+            if process_data:
+                process_data["generation"]["time"] = round(time.time() - start_time, 3)
+                yield {"process_data": process_data}
+                
+        except Exception as e:
+            yield f"连接错误: {str(e)}"

modules/knowledge_base/processor.py

@@ -0,0 +1,201 @@
+from typing import List, Dict, Callable, Optional
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import (
+    DirectoryLoader,
+    UnstructuredMarkdownLoader,
+    PyPDFLoader,
+    TextLoader
+)
+import os
+import requests
+import base64
+from PIL import Image
+import io
+
+class DocumentLoader:
+    """通用文档加载器"""
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+        self.extension = os.path.splitext(file_path)[1].lower()
+        self.api_key = os.getenv("API_KEY")
+        self.api_base = os.getenv("BASE_URL")
+        
+    def process_image(self, image_path: str) -> str:
+        """使用 SiliconFlow VLM 模型处理图片"""
+        try:
+            # 读取图片并转换为base64
+            with open(image_path, 'rb') as image_file:
+                image_data = image_file.read()
+                base64_image = base64.b64encode(image_data).decode('utf-8')
+            
+            # 调用 SiliconFlow API
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json"
+            }
+            
+            response = requests.post(
+                f"{self.api_base}/chat/completions",
+                headers=headers,
+                json={
+                    "model": "Qwen/Qwen2.5-VL-72B-Instruct",
+                    "messages": [
+                        {
+                            "role": "user",
+                            "content": [
+                                {
+                                    "type": "image_url",
+                                    "image_url": {
+                                        "url": f"data:image/jpeg;base64,{base64_image}",
+                                        "detail": "high"
+                                    }
+                                },
+                                {
+                                    "type": "text",
+                                    "text": "请详细描述这张图片的内容，包括主要对象、场景、活动、颜色、布局等关键信息。"
+                                }
+                            ]
+                        }
+                    ],
+                    "temperature": 0.7,
+                    "max_tokens": 500
+                }
+            )
+            
+            if response.status_code != 200:
+                raise Exception(f"图片处理API调用失败: {response.text}")
+                
+            description = response.json()["choices"][0]["message"]["content"]
+            return description
+            
+        except Exception as e:
+            print(f"处理图片时出错: {str(e)}")
+            return "图片处理失败"
+    
+    def load(self):
+        try:
+            if self.extension == '.md':
+                loader = UnstructuredMarkdownLoader(self.file_path, encoding='utf-8')
+                return loader.load()
+            elif self.extension == '.pdf':
+                loader = PyPDFLoader(self.file_path)
+                return loader.load()
+            elif self.extension == '.txt':
+                loader = TextLoader(self.file_path, encoding='utf-8')
+                return loader.load()
+            elif self.extension in ['.png', '.jpg', '.jpeg', '.gif', '.bmp']:
+                # 处理图片
+                description = self.process_image(self.file_path)
+                # 创建一个包含图片描述的文档
+                from langchain.schema import Document
+                doc = Document(
+                    page_content=description,
+                    metadata={
+                        'source': self.file_path,
+                        'img_url': os.path.abspath(self.file_path)  # 存储图片的绝对路径
+                    }
+                )
+                return [doc]
+            else:
+                raise ValueError(f"不支持的文件格式: {self.extension}")
+                
+        except UnicodeDecodeError:
+            # 如果 utf-8 失败，尝试 gbk
+            if self.extension in ['.md', '.txt']:
+                loader = TextLoader(self.file_path, encoding='gbk')
+                return loader.load()
+            raise
+
+class DocumentProcessor:
+    def __init__(self):
+        self.text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=1000,
+            chunk_overlap=200,
+            length_function=len,
+        )
+        
+    def get_index_name(self, path: str) -> str:
+        """根据文件路径生成索引名称"""
+        if os.path.isdir(path):
+            # 如果是目录，使用目录名
+            return f"rag_{os.path.basename(path).lower()}"
+        else:
+            # 如果是文件，使用文件名（不含扩展名）
+            return f"rag_{os.path.splitext(os.path.basename(path))[0].lower()}"
+        
+    def process(self, path: str, progress_callback: Optional[Callable] = None) -> List[Dict]:
+        """
+        ��载并处理文档，支持目录或单个文件
+        参数：
+            path: 文档路径
+            progress_callback: 进度回调函数，用于报告处理进度
+        返回：处理后的文档列表
+        """
+        if os.path.isdir(path):
+            documents = []
+            total_files = sum([len(files) for _, _, files in os.walk(path)])
+            processed_files = 0
+            processed_size = 0
+            
+            for root, _, files in os.walk(path):
+                for file in files:
+                    file_path = os.path.join(root, file)
+                    try:
+                        # 更新处理进度
+                        if progress_callback:
+                            file_size = os.path.getsize(file_path)
+                            processed_size += file_size
+                            processed_files += 1
+                            progress_callback(processed_size, f"处理文件 {processed_files}/{total_files}: {file}")
+                            
+                        loader = DocumentLoader(file_path)
+                        docs = loader.load()
+                        # 添加文件名到metadata
+                        for doc in docs:
+                            doc.metadata['file_name'] = os.path.basename(file_path)
+                        documents.extend(docs)
+                    except Exception as e:
+                        print(f"警告：加载文件 {file_path} 时出错: {str(e)}")
+                        continue
+        else:
+            try:
+                if progress_callback:
+                    file_size = os.path.getsize(path)
+                    progress_callback(file_size * 0.3, f"加载文件: {os.path.basename(path)}")
+                    
+                loader = DocumentLoader(path)
+                documents = loader.load()
+                
+                # 更新进度
+                if progress_callback:
+                    progress_callback(file_size * 0.6, f"处理文件内容...")
+                    
+                # 添加文件名到metadata
+                file_name = os.path.basename(path)
+                for doc in documents:
+                    doc.metadata['file_name'] = file_name
+            except Exception as e:
+                print(f"加载文件时出错: {str(e)}")
+                raise
+        
+        # 分块
+        chunks = self.text_splitter.split_documents(documents)
+        
+        # 更新进度
+        if progress_callback:
+            if os.path.isdir(path):
+                progress_callback(processed_size, f"文档分块完成，共{len(chunks)}个文档片段")
+            else:
+                file_size = os.path.getsize(path)
+                progress_callback(file_size * 0.9, f"文档分块完成，共{len(chunks)}个文档片段")
+        
+        # 处理成统一格式
+        processed_docs = []
+        for i, chunk in enumerate(chunks):
+            processed_docs.append({
+                'id': f'doc_{i}',
+                'content': chunk.page_content,
+                'metadata': chunk.metadata
+            })
+            
+        return processed_docs

modules/knowledge_base/reranker.py

@@ -0,0 +1,49 @@
+from typing import List, Dict
+import requests
+import time
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+class Reranker:
+    def __init__(self):
+        self.api_key = os.getenv("API_KEY")
+        self.api_base = os.getenv("BASE_URL")
+        
+    def rerank(self, query: str, documents: List[Dict], index_name: str, top_k: int = 5) -> List[Dict]:
+        """使用SiliconFlow的rerank API重排序文档"""
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        # 准备文档列表
+        docs = [doc['content'] for doc in documents]
+        
+        response = requests.post(
+            f"{self.api_base}/rerank",
+            headers=headers,
+            json={
+                "model": "BAAI/bge-reranker-v2-m3",
+                "query": query,
+                "documents": docs,
+                "top_n": top_k
+            }
+        )
+        
+        if response.status_code != 200:
+            raise Exception(f"Error in reranking: {response.text}")
+            
+        # 处理结果
+        results = response.json()["results"]
+        reranked_docs = []
+        
+        for result in results:
+            doc_index = result["index"]
+            original_doc = documents[doc_index].copy()
+            original_doc['rerank_score'] = result["relevance_score"]
+            original_doc['index_name'] = index_name  
+            reranked_docs.append(original_doc)
+            
+        return reranked_docs

modules/knowledge_base/retriever.py

@@ -0,0 +1,109 @@
+from typing import List, Dict, Tuple
+import requests
+from elasticsearch import Elasticsearch
+import os
+import time
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Retriever:
+    def __init__(self):
+        # 使用与 vector_store.py 相同的 ES 配置
+        self.es = Elasticsearch(
+            "https://samlax12-elastic.hf.space",  # 注意是 https
+            basic_auth=("elastic", os.getenv("PASSWORD")),  # 使用相同的密码
+            verify_certs=False  # 开发环境可以禁用证书验证
+        )
+        self.api_key = os.getenv("API_KEY")
+        self.api_base = os.getenv("BASE_URL")
+        
+    def get_embedding(self, text: str) -> List[float]:
+        """调用SiliconFlow的embedding API获取向量"""
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        response = requests.post(
+            f"{self.api_base}/embeddings",
+            headers=headers,
+            json={
+                "model": "BAAI/bge-m3",
+                "input": text
+            }
+        )
+        
+        if response.status_code == 200:
+            return response.json()["data"][0]["embedding"]
+        else:
+            raise Exception(f"Error getting embedding: {response.text}")
+    
+    def get_all_indices(self) -> List[str]:
+        """获取所有 RAG 相关的索引"""
+        indices = self.es.indices.get_alias().keys()
+        return [idx for idx in indices if idx.startswith('rag_')]
+        
+    def retrieve(self, query: str, top_k: int = 10, specific_index: str = None) -> Tuple[List[Dict], str]:
+        """混合检索：结合 BM25 和向量检索，支持指定特定索引"""
+        # 获取检索索引
+        if specific_index:
+            indices = [specific_index] if self.es.indices.exists(index=specific_index) else []
+        else:
+            indices = self.get_all_indices()
+            
+        if not indices:
+            raise Exception("没有找到可用的文档索引！")
+            
+        # 计算查询向量
+        query_vector = self.get_embedding(query)
+        
+        # 在所有索引中搜索
+        all_results = []
+        for index in indices:
+            # 构建混合查询
+            script_query = {
+                "script_score": {
+                    "query": {
+                        "match": {
+                            "content": query  # BM25
+                        }
+                    },
+                    "script": {
+                        "source": "cosineSimilarity(params.query_vector, 'vector') + 1.0",
+                        "params": {"query_vector": query_vector}
+                    }
+                }
+            }
+            
+            # 执行检索
+            response = self.es.search(
+                index=index,
+                body={
+                    "query": script_query,
+                    "size": top_k
+                }
+            )
+            
+            # 处理结果
+            for hit in response['hits']['hits']:
+                result = {
+                    'id': hit['_id'],
+                    'content': hit['_source']['content'],
+                    'score': hit['_score'],
+                    'metadata': hit['_source']['metadata'],
+                    'index': index
+                }
+                all_results.append(result)
+        
+        # 按分数排序并选择最相关的文档
+        all_results.sort(key=lambda x: x['score'], reverse=True)
+        top_results = all_results[:top_k]
+        
+        # 如果有结果，返回最相关文档所在的索引
+        if top_results:
+            most_relevant_index = top_results[0]['index']
+        else:
+            most_relevant_index = indices[0] if indices else ""
+            
+        return top_results, most_relevant_index

modules/knowledge_base/routes.py

@@ -0,0 +1,268 @@
+# modules/knowledge_base/routes.py
+from flask import Blueprint, request, jsonify
+import os
+import time
+import threading
+import uuid
+from werkzeug.utils import secure_filename
+
+# Import existing components
+from modules.knowledge_base.processor import DocumentProcessor
+from modules.knowledge_base.vector_store import VectorStore
+from modules.knowledge_base.retriever import Retriever
+from modules.knowledge_base.reranker import Reranker
+
+knowledge_bp = Blueprint('knowledge', __name__)
+
+# Initialize components
+doc_processor = DocumentProcessor()
+vector_store = VectorStore()
+retriever = Retriever()
+reranker = Reranker()
+
+# Store progress information
+processing_tasks = {}
+
+# Upload folder configuration
+UPLOAD_FOLDER = "uploads"
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+@knowledge_bp.route('/', methods=['GET'])
+def get_all_knowledge():
+    """Get all knowledge base information"""
+    try:
+        indices = retriever.get_all_indices()
+        result = []
+        
+        for index in indices:
+            display_name = index[4:] if index.startswith('rag_') else index
+            files = vector_store.get_files_in_index(index)
+            result.append({
+                "id": index,
+                "name": display_name,
+                "files": files,
+                "fileCount": len(files)
+            })
+            
+        return jsonify({"success": True, "data": result})
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({"success": False, "message": str(e)}), 500
+
+@knowledge_bp.route('/', methods=['POST'])
+def create_knowledge():
+    """Create a new knowledge base"""
+    try:
+        data = request.form
+        name = data.get('name')
+        
+        if not name:
+            return jsonify({"success": False, "message": "Knowledge base name cannot be empty"}), 400
+            
+        # Check if knowledge base already exists
+        indices = retriever.get_all_indices()
+        if f"rag_{name}" in indices:
+            return jsonify({"success": False, "message": f"Knowledge base '{name}' already exists"}), 400
+            
+        # Process uploaded file
+        if 'file' not in request.files:
+            return jsonify({"success": False, "message": "No file uploaded"}), 400
+            
+        file = request.files['file']
+        if file.filename == '':
+            return jsonify({"success": False, "message": "No file selected"}), 400
+            
+        # Save file
+        filename = secure_filename(file.filename)
+        file_path = os.path.join(UPLOAD_FOLDER, filename)
+        file.save(file_path)
+        
+        # Create task ID
+        task_id = f"task_{int(time.time())}_{name}"
+        
+        # Initialize task status
+        processing_tasks[task_id] = {
+            "progress": 0,
+            "status": "Starting document processing...",
+            "index_name": name,
+            "file_path": file_path,
+            "error": False,
+            "docCount": 0
+        }
+        
+        # Process documents in a separate thread
+        def process_in_thread():
+            try:
+                # Update task status
+                processing_tasks[task_id]["progress"] = 10
+                processing_tasks[task_id]["status"] = "Loading document..."
+                
+                # Process document with progress tracking
+                def update_progress(progress, status):
+                    processing_tasks[task_id]["progress"] = min(95, progress)
+                    processing_tasks[task_id]["status"] = status
+                
+                # Process the document
+                processed_docs = doc_processor.process(file_path, progress_callback=update_progress)
+                
+                # Update task status
+                processing_tasks[task_id]["progress"] = 95
+                processing_tasks[task_id]["status"] = "Creating vector store..."
+                processing_tasks[task_id]["docCount"] = len(processed_docs)
+                
+                # Store vectors
+                vector_store.store(processed_docs, f"rag_{name}")
+                
+                # Complete task
+                processing_tasks[task_id]["progress"] = 100
+                processing_tasks[task_id]["status"] = "Processing complete"
+                
+            except Exception as e:
+                # Record error
+                processing_tasks[task_id]["error"] = True
+                processing_tasks[task_id]["status"] = f"Processing failed: {str(e)}"
+                import traceback
+                traceback.print_exc()
+        
+        threading.Thread(target=process_in_thread).start()
+        
+        return jsonify({
+            "success": True, 
+            "message": "Started processing document", 
+            "task_id": task_id
+        }), 202
+    
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({"success": False, "message": str(e)}), 500
+
+@knowledge_bp.route('/progress/<task_id>', methods=['GET'])
+def get_progress(task_id):
+    """Get document processing progress"""
+    try:
+        task_data = processing_tasks.get(task_id, {
+            "progress": 0,
+            "status": "Task not found",
+            "error": True
+        })
+        
+        return jsonify({"success": True, "data": task_data})
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({"success": False, "message": str(e)}), 500
+
+@knowledge_bp.route('/<index_id>/documents', methods=['POST'])
+def add_documents(index_id):
+    """Add documents to a knowledge base"""
+    try:
+        # Check if knowledge base exists
+        indices = retriever.get_all_indices()
+        if index_id not in indices:
+            return jsonify({"success": False, "message": "Knowledge base does not exist"}), 404
+            
+        # Process uploaded file
+        if 'file' not in request.files:
+            return jsonify({"success": False, "message": "No file uploaded"}), 400
+            
+        file = request.files['file']
+        if file.filename == '':
+            return jsonify({"success": False, "message": "No file selected"}), 400
+            
+        # Save file
+        filename = secure_filename(file.filename)
+        file_path = os.path.join(UPLOAD_FOLDER, filename)
+        file.save(file_path)
+        
+        # Extract knowledge base name from index ID
+        kb_name = index_id[4:] if index_id.startswith('rag_') else index_id
+        
+        # Create task ID
+        task_id = f"task_{int(time.time())}_{kb_name}_{filename}"
+        
+        # Initialize task status
+        processing_tasks[task_id] = {
+            "progress": 0,
+            "status": "Starting document processing...",
+            "index_name": kb_name,
+            "file_path": file_path,
+            "error": False,
+            "docCount": 0
+        }
+        
+        # Process documents in a separate thread
+        def process_in_thread():
+            try:
+                # Update task status
+                processing_tasks[task_id]["progress"] = 10
+                processing_tasks[task_id]["status"] = "Loading document..."
+                
+                # Process document with progress tracking
+                def update_progress(progress, status):
+                    processing_tasks[task_id]["progress"] = min(95, progress)
+                    processing_tasks[task_id]["status"] = status
+                
+                # Process the document
+                processed_docs = doc_processor.process(file_path, progress_callback=update_progress)
+                
+                # Update task status
+                processing_tasks[task_id]["progress"] = 95
+                processing_tasks[task_id]["status"] = "Creating vector store..."
+                processing_tasks[task_id]["docCount"] = len(processed_docs)
+                
+                # Store vectors
+                vector_store.store(processed_docs, index_id)
+                
+                # Complete task
+                processing_tasks[task_id]["progress"] = 100
+                processing_tasks[task_id]["status"] = "Processing complete"
+                
+            except Exception as e:
+                # Record error
+                processing_tasks[task_id]["error"] = True
+                processing_tasks[task_id]["status"] = f"Processing failed: {str(e)}"
+                import traceback
+                traceback.print_exc()
+        
+        threading.Thread(target=process_in_thread).start()
+        
+        return jsonify({
+            "success": True, 
+            "message": "Started processing document", 
+            "task_id": task_id
+        }), 202
+    
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({"success": False, "message": str(e)}), 500
+
+@knowledge_bp.route('/<index_id>', methods=['DELETE'])
+def delete_knowledge(index_id):
+    """Delete a knowledge base"""
+    try:
+        result = vector_store.delete_index(index_id)
+        if result:
+            return jsonify({"success": True, "message": "Knowledge base deleted successfully"})
+        else:
+            return jsonify({"success": False, "message": "Failed to delete knowledge base"})
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({"success": False, "message": str(e)}), 500
+
+@knowledge_bp.route('/<index_id>/documents/<path:file_name>', methods=['DELETE'])
+def delete_document(index_id, file_name):
+    """Delete a document from a knowledge base"""
+    try:
+        result = vector_store.delete_document(index_id, file_name)
+        if result:
+            return jsonify({"success": True, "message": "Document deleted successfully"})
+        else:
+            return jsonify({"success": False, "message": "Failed to delete document"})
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({"success": False, "message": str(e)}), 500

modules/knowledge_base/vector_store.py

@@ -0,0 +1,187 @@
+from typing import List, Dict
+import requests
+import numpy as np
+from elasticsearch import Elasticsearch
+import urllib3
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+class VectorStore:
+    def __init__(self):
+        # ES 8.x 的连接配置
+        self.es = Elasticsearch(
+            "https://samlax12-elastic.hf.space",
+            basic_auth=("elastic", os.getenv("PASSWORD")),
+            verify_certs=False,
+            request_timeout=30,
+            # 忽略系统索引警告
+            headers={"accept": "application/vnd.elasticsearch+json; compatible-with=8"},
+        )
+        self.api_key = os.getenv("API_KEY")
+        self.api_base = os.getenv("BASE_URL")
+        
+    def get_embedding(self, text: str) -> List[float]:
+        """调用SiliconFlow的embedding API获取向量"""
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        response = requests.post(
+            f"{self.api_base}/embeddings",
+            headers=headers,
+            json={
+                "model": "BAAI/bge-m3",
+                "input": text
+            }
+        )
+        
+        if response.status_code == 200:
+            return response.json()["data"][0]["embedding"]
+        else:
+            raise Exception(f"Error getting embedding: {response.text}")
+    
+    def store(self, documents: List[Dict], index_name: str) -> None:
+        """将文档存储到 Elasticsearch"""
+        # 创建索引（如果不存在）
+        if not self.es.indices.exists(index=index_name):
+            self.create_index(index_name)
+        
+        # 获取当前索引中的文档数量
+        try:
+            response = self.es.count(index=index_name)
+            last_id = response['count'] - 1  # 文档数量减1作为最后的ID
+            if last_id < 0:
+                last_id = -1
+        except Exception as e:
+            print(f"获取文档数量时出错，假设为-1: {str(e)}")
+            last_id = -1
+        
+        # 批量索引文档
+        bulk_data = []
+        for i, doc in enumerate(documents, start=last_id + 1):
+            # 获取文档向量
+            vector = self.get_embedding(doc['content'])
+            
+            # 准备索引数据
+            bulk_data.append({
+                "index": {
+                    "_index": index_name,
+                    "_id": f"doc_{i}"
+                }
+            })
+            
+            # 构建文档数据，包含新的img_url字段
+            doc_data = {
+                "content": doc['content'],
+                "vector": vector,
+                "metadata": {
+                    "file_name": doc['metadata'].get('file_name', '未知文件'),
+                    "source": doc['metadata'].get('source', ''),
+                    "page": doc['metadata'].get('page', ''),
+                    "img_url": doc['metadata'].get('img_url', '')  # 添加img_url字段
+                }
+            }
+            bulk_data.append(doc_data)
+            
+        # 批量写入
+        if bulk_data:
+            response = self.es.bulk(operations=bulk_data, refresh=True)
+            if response.get('errors'):
+                print("批量写入时出现错误：", response)
+    
+    def get_files_in_index(self, index_name: str) -> List[str]:
+        """获取索引中的所有文件名"""
+        try:
+            response = self.es.search(
+                index=index_name,
+                body={
+                    "size": 0,
+                    "aggs": {
+                        "unique_files": {
+                            "terms": {
+                                "field": "metadata.file_name",
+                                "size": 1000
+                            }
+                        }
+                    }
+                }
+            )
+            
+            files = [bucket['key'] for bucket in response['aggregations']['unique_files']['buckets']]
+            return sorted(files)
+        except Exception as e:
+            print(f"获取文件列表时出错: {str(e)}")
+            return []
+
+    def create_index(self, index_name: str):
+        """创建 Elasticsearch 索引"""
+        settings = {
+            "mappings": {
+                "properties": {
+                    "content": {"type": "text"},
+                    "vector": {
+                        "type": "dense_vector",
+                        "dims": 1024
+                    },
+                    "metadata": {
+                        "properties": {
+                            "file_name": {
+                                "type": "keyword",
+                                "ignore_above": 256
+                            },
+                            "source": {
+                                "type": "keyword"
+                            },
+                            "page": {
+                                "type": "keyword"
+                            },
+                            "img_url": {  # 新增图片URL字段
+                                "type": "keyword",
+                                "ignore_above": 2048
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        
+        # 如果索引已存在，先删除
+        if self.es.indices.exists(index=index_name):
+            self.es.indices.delete(index=index_name)
+        
+        self.es.indices.create(index=index_name, body=settings)
+        
+    def delete_index(self, index_id: str) -> bool:
+        """删除一个索引"""
+        try:
+            if self.es.indices.exists(index=index_id):
+                self.es.indices.delete(index=index_id)
+                return True
+            return False
+        except Exception as e:
+            print(f"删除索引时出错: {str(e)}")
+            return False
+            
+    def delete_document(self, index_id: str, file_name: str) -> bool:
+        """根据文件名删除文档"""
+        try:
+            response = self.es.delete_by_query(
+                index=index_id,
+                body={
+                    "query": {
+                        "term": {
+                            "metadata.file_name": file_name
+                        }
+                    }
+                },
+                refresh=True
+            )
+            return True
+        except Exception as e:
+            print(f"删除文档时出错: {str(e)}")
+            return False

modules/visualization/routes.py

@@ -0,0 +1,244 @@
+# modules/visualization/routes.py
+from flask import Blueprint, request, jsonify, send_file
+import os
+import time
+import re
+import requests
+import plotly.graph_objects as go
+import numpy as np
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.pyplot as plt
+from io import BytesIO
+import matplotlib
+import json
+matplotlib.use('Agg')  # 非交互式后端
+
+visualization_bp = Blueprint('visualization', __name__)
+
+# 确保存储目录存在
+os.makedirs('static', exist_ok=True)
+
+@visualization_bp.route('/mindmap', methods=['POST'])
+def generate_mindmap():
+    """生成思维导图"""
+    try:
+        data = request.json
+        content = data.get('content', '')
+        
+        if not content:
+            return jsonify({
+                "success": False,
+                "message": "思维导图内容不能为空"
+            }), 400
+        
+        # 提取@startmindmap和@endmindmap之间的内容
+        pattern = r'@startmindmap\n([\s\S]*?)@endmindmap'
+        match = re.search(pattern, content)
+        
+        if match:
+            processed_content = f"@startmindmap\n{match.group(1)}\n@endmindmap"
+        else:
+            # 如果内容中没有正确格式，直接使用原始内容
+            processed_content = content
+            
+            # 确保内容有开始和结束标记
+            if '@startmindmap' not in processed_content:
+                processed_content = "@startmindmap\n" + processed_content
+            if '@endmindmap' not in processed_content:
+                processed_content += "\n@endmindmap"
+        
+        # 使用HuggingFace Space API生成图像
+        response = requests.post(
+            'https://mistpe-flask.hf.space/v1/images/generations',
+            headers={
+                'Authorization': 'Bearer sk-xxx',  # 实际应用中应从配置中获取
+                'Content-Type': 'application/json'
+            },
+            json={
+                'model': 'dall-e-3',
+                'prompt': processed_content,
+                'n': 1,
+                'size': '1024x1024'
+            }
+        )
+        
+        if response.status_code != 200:
+            return jsonify({
+                "success": False,
+                "message": "生成思维导图图像失败",
+                "status_code": response.status_code
+            }), 500
+            
+        response_data = response.json()
+        
+        if not response_data.get('data') or not response_data['data'][0].get('url'):
+            return jsonify({
+                "success": False,
+                "message": "API返回的数据中没有图像URL"
+            }), 500
+            
+        image_url = response_data['data'][0]['url']
+        
+        # 下载图像并保存到本地
+        img_response = requests.get(image_url)
+        if img_response.status_code != 200:
+            return jsonify({
+                "success": False,
+                "message": "下载生成的图像失败"
+            }), 500
+            
+        # 保存图像到本地
+        img_filename = f'mindmap_{int(time.time())}.png'
+        img_path = os.path.join('static', img_filename)
+        
+        with open(img_path, 'wb') as f:
+            f.write(img_response.content)
+        
+        # 构建URL
+        local_img_url = f'/static/{img_filename}'
+        
+        return jsonify({
+            "success": True,
+            "url": local_img_url,
+            "original_url": image_url,
+            "message": "思维导图生成成功"
+        })
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({
+            "success": False,
+            "message": str(e)
+        }), 500
+@visualization_bp.route('/3d-surface', methods=['POST'])
+def generate_3d_surface():
+    """生成3D表面图并返回嵌入式HTML"""
+    try:
+        data = request.json
+        code = data.get('code', '')
+        
+        if not code:
+            return jsonify({
+                "success": False,
+                "message": "请提供函数代码"
+            }), 400
+        
+        # 清理代码（移除可能的Markdown标记）
+        code = re.sub(r'```python\n', '', code)
+        code = re.sub(r'```', '', code)
+        
+        # 在安全环境中执行代码
+        local_vars = {}
+        try:
+            # 仅提供numpy库
+            exec(code, {"__builtins__": __builtins__, "np": np, "numpy": np}, local_vars)
+            
+            # 检查是否有create_3d_plot函数
+            if 'create_3d_plot' not in local_vars:
+                return jsonify({
+                    "success": False,
+                    "message": "提供的代码未包含create_3d_plot函数"
+                }), 500
+            
+            # 执行函数获取数据
+            plot_data = local_vars['create_3d_plot']()
+            
+            if not isinstance(plot_data, dict) or not all(k in plot_data for k in ['x', 'y', 'z']):
+                return jsonify({
+                    "success": False,
+                    "message": "函数未返回有效的3D数据"
+                }), 500
+            
+            # 创建Plotly图形
+            fig = go.Figure()
+            
+            # 根据类型添加跟踪
+            if plot_data.get('type') == 'scatter3d':
+                fig.add_trace(go.Scatter3d(
+                    x=plot_data['x'],
+                    y=plot_data['y'],
+                    z=plot_data['z'],
+                    mode='markers',
+                    marker=dict(
+                        size=4,
+                        color=plot_data.get('color', plot_data['z']),
+                        colorscale='Viridis',
+                        opacity=0.8
+                    )
+                ))
+            else:  # 默认为surface
+                # 处理数据格式
+                try:
+                    x = np.array(plot_data['x'])
+                    y = np.array(plot_data['y'])
+                    z = np.array(plot_data['z'])
+                    
+                    if len(x.shape) == 1 and len(y.shape) == 1:
+                        X, Y = np.meshgrid(x, y)
+                        if len(z.shape) == 1:
+                            Z = z.reshape(len(y), len(x))
+                        else:
+                            Z = z
+                    else:
+                        X = x
+                        Y = y
+                        Z = z
+                        
+                    fig.add_trace(go.Surface(
+                        z=Z,
+                        x=X,
+                        y=Y,
+                        colorscale='Viridis'
+                    ))
+                except Exception as data_error:
+                    return jsonify({
+                        "success": False,
+                        "message": f"处理3D数据时出错: {str(data_error)}"
+                    }), 500
+            
+            # 设置图形布局
+            fig.update_layout(
+                title=plot_data.get('title', '3D 可视化'),
+                scene=dict(
+                    xaxis_title='X',
+                    yaxis_title='Y',
+                    zaxis_title='Z'
+                ),
+                width=800,
+                height=600,
+                margin=dict(l=0, r=0, b=0, t=30)  # 减小边距，使图形更紧凑
+            )
+            
+            # 直接生成HTML
+            html_content = fig.to_html(include_plotlyjs=True, full_html=True)
+            
+            # 保存为文件
+            html_filename = f'3d_plot_{int(time.time())}.html'
+            html_path = os.path.join('static', html_filename)
+            
+            with open(html_path, 'w', encoding='utf-8') as f:
+                f.write(html_content)
+            
+            return jsonify({
+                "success": True,
+                "html_url": f'/static/{html_filename}',
+                "message": "3D图形生成成功"
+            })
+            
+        except Exception as e:
+            import traceback
+            error_traceback = traceback.format_exc()
+            print(f"3D可视化执行错误: {error_traceback}")
+            return jsonify({
+                "success": False,
+                "message": f"执行代码时出错: {str(e)}"
+            }), 500
+            
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({
+            "success": False,
+            "message": str(e)
+        }), 500

requirements.txt

@@ -0,0 +1,12 @@
+flask
+flask_cors
+python-dotenv
+requests
+openai
+elasticsearch
+psutil
+urllib3
+matplotlib
+plotly
+numpy
+pillow

templates/code_execution.html

@@ -0,0 +1,718 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AI代码助手 - Python执行环境</title>
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css">
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/[email protected]/font/bootstrap-icons.css">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.8.0/styles/vs2015.min.css">
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.8.0/highlight.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.8.0/languages/python.min.js"></script>
+    <style>
+        /* Base styles */
+        :root {
+            --primary-color: #4361ee;
+            --secondary-color: #3f37c9;
+            --accent-color: #4cc9f0;
+            --success-color: #4caf50;
+            --warning-color: #ff9800;
+            --danger-color: #f44336;
+            --light-color: #f8f9fa;
+            --dark-color: #212529;
+            --border-color: #dee2e6;
+            --border-radius: 0.375rem;
+        }
+        
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            margin: 0;
+            padding: 0;
+            height: 100vh;
+            background-color: #f5f7fa;
+            color: #333;
+            display: flex;
+            flex-direction: column;
+        }
+        
+        /* Layout structure */
+        .workspace {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 16px;
+            flex: 1;
+            padding: 16px;
+        }
+        
+        @media (max-width: 992px) {
+            .workspace {
+                grid-template-columns: 1fr;
+            }
+        }
+        
+        .section {
+            background: #fff;
+            border-radius: var(--border-radius);
+            overflow: hidden;
+            display: flex;
+            flex-direction: column;
+            border: 1px solid var(--border-color);
+            box-shadow: 0 2px 5px rgba(0, 0, 0, 0.05);
+        }
+        
+        .section-header {
+            background: #f8f9fa;
+            padding: 12px 16px;
+            border-bottom: 1px solid var(--border-color);
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        
+        .section-title {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 1rem;
+            font-weight: 500;
+        }
+        
+        /* Code editor styles */
+        .editor-content {
+            flex: 1;
+            position: relative;
+            overflow: hidden;
+        }
+        
+        .code-area {
+            position: absolute;
+            left: 40px;
+            right: 0;
+            top: 0;
+            bottom: 0;
+            padding: 12px 16px;
+            color: #333;
+            font-family: 'JetBrains Mono', 'Fira Code', monospace;
+            font-size: 14px;
+            line-height: 1.6;
+            overflow: auto;
+        }
+        
+        .code-area pre {
+            margin: 0;
+            padding: 0;
+            background: none;
+            border: none;
+        }
+        
+        .code-area code {
+            display: block;
+            padding: 0;
+            tab-size: 4;
+            font-family: 'JetBrains Mono', 'Fira Code', monospace;
+            outline: none;
+            position: relative;
+            min-height: 100%;
+            white-space: pre !important;
+            word-wrap: normal !important;
+        }
+        
+        .line-numbers {
+            position: absolute;
+            left: 0;
+            top: 0;
+            bottom: 0;
+            width: 40px;
+            padding: 12px 0;
+            background: #f5f7fa;
+            border-right: 1px solid #e9ecef;
+            text-align: center;
+            color: #6c757d;
+            font-family: 'JetBrains Mono', 'Fira Code', monospace;
+            font-size: 14px;
+            line-height: 1.6;
+            user-select: none;
+        }
+        
+        /* Terminal styles */
+        .output-content {
+            flex: 1;
+            background: #f8f9fa;
+            position: relative;
+            overflow: hidden;
+            display: flex;
+            flex-direction: column;
+        }
+        
+        .terminal-window {
+            flex: 1;
+            overflow-y: auto;
+            background: #212529;
+            color: #f8f9fa;
+        }
+        
+        #output {
+            color: #f8f9fa;
+            margin: 0;
+            padding: 12px 16px;
+            background: transparent;
+            border: none;
+            white-space: pre-wrap;
+            word-wrap: break-word;
+            line-height: 1.6;
+            font-size: 14px;
+            font-family: 'JetBrains Mono', 'Fira Code', monospace;
+        }
+        
+        .console-input-container {
+            display: flex;
+            align-items: center;
+            background: #343a40;
+            border-top: 1px solid #495057;
+            padding: 8px 12px;
+        }
+        
+        .console-prompt {
+            color: #4caf50;
+            font-family: 'JetBrains Mono', 'Fira Code', monospace;
+            margin-right: 8px;
+            font-size: 14px;
+            user-select: none;
+        }
+        
+        .console-input {
+            flex: 1;
+            background: transparent;
+            border: none;
+            color: #f8f9fa;
+            font-family: 'JetBrains Mono', 'Fira Code', monospace;
+            font-size: 14px;
+            line-height: 1.5;
+            padding: 4px 0;
+        }
+        
+        .console-input:focus {
+            outline: none;
+        }
+        
+        /* Chat section */
+        .chat-section {
+            display: flex;
+            flex-direction: column;
+            height: 100%;
+        }
+        
+        .chat-messages {
+            flex: 1;
+            overflow-y: auto;
+            padding: 16px;
+        }
+        
+        .message {
+            margin-bottom: 16px;
+            padding: 12px;
+            border-radius: var(--border-radius);
+            max-width: 85%;
+            position: relative;
+        }
+        
+        .message.user {
+            background-color: #e3f2fd;
+            color: #0d47a1;
+            align-self: flex-end;
+            margin-left: auto;
+        }
+        
+        .message.bot {
+            background-color: #f5f5f5;
+            color: #333;
+            align-self: flex-start;
+            border-left: 3px solid var(--primary-color);
+        }
+        
+        .chat-input-container {
+            padding: 16px;
+            border-top: 1px solid var(--border-color);
+            background-color: #f9f9f9;
+        }
+        
+        .input-row {
+            display: flex;
+            gap: 8px;
+        }
+        
+        .chat-input {
+            flex: 1;
+            padding: 12px;
+            border: 1px solid var(--border-color);
+            border-radius: var(--border-radius);
+            resize: none;
+            font-size: 14px;
+            height: 100px;
+        }
+        
+        .chat-input:focus {
+            outline: none;
+            border-color: var(--primary-color);
+            box-shadow: 0 0 0 3px rgba(67, 97, 238, 0.1);
+        }
+        
+        /* Button styles */
+        .btn {
+            padding: 8px 16px;
+            border: none;
+            border-radius: var(--border-radius);
+            cursor: pointer;
+            font-weight: 500;
+            font-size: 14px;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            transition: all 0.2s ease;
+        }
+        
+        .btn-primary {
+            background-color: var(--primary-color);
+            color: white;
+        }
+        
+        .btn-primary:hover {
+            background-color: var(--secondary-color);
+        }
+        
+        .btn-secondary {
+            background-color: #6c757d;
+            color: white;
+        }
+        
+        .btn-secondary:hover {
+            background-color: #5a6268;
+        }
+        
+        .btn-danger {
+            background-color: var(--danger-color);
+            color: white;
+        }
+        
+        .btn-danger:hover {
+            background-color: #d32f2f;
+        }
+        
+        /* Utilities */
+        .loading {
+            display: none;
+            align-items: center;
+            gap: 8px;
+            color: #6c757d;
+            font-size: 14px;
+        }
+        
+        .loading.active {
+            display: flex;
+        }
+        
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+        
+        .loading i {
+            animation: spin 1s linear infinite;
+        }
+        
+        /* Custom scrollbar */
+        ::-webkit-scrollbar {
+            width: 8px;
+            height: 8px;
+        }
+        
+        ::-webkit-scrollbar-track {
+            background: #f1f1f1;
+        }
+        
+        ::-webkit-scrollbar-thumb {
+            background: #c1c1c1;
+            border-radius: 4px;
+        }
+        
+        ::-webkit-scrollbar-thumb:hover {
+            background: #a8a8a8;
+        }
+        
+        /* Terminal text styles */
+        .term-input {
+            color: #4caf50;
+        }
+        
+        .term-output {
+            color: #f8f9fa;
+        }
+        
+        .term-error {
+            color: #f44336;
+        }
+        
+        .term-warning {
+            color: #ff9800;
+        }
+        
+        .term-system {
+            color: #2196f3;
+        }
+        
+        /* Header */
+        .header {
+            background-color: #fff;
+            border-bottom: 1px solid var(--border-color);
+            padding: 1rem;
+            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+        }
+        
+        .header-content {
+            max-width: 1200px;
+            margin: 0 auto;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        
+        .header h1 {
+            margin: 0;
+            font-size: 1.5rem;
+            color: var(--primary-color);
+        }
+    </style>
+</head>
+<body>
+    <header class="header">
+        <div class="header-content">
+            <h1>AI代码助手</h1>
+            <div>
+                <span class="badge bg-primary">Python编程环境</span>
+            </div>
+        </div>
+    </header>
+    
+    <div class="workspace">
+        <div class="section">
+            <div class="section-header">
+                <div class="section-title">
+                    <i class="bi bi-code-square"></i>
+                    代码编辑器
+                </div>
+                <div style="display: flex; gap: 8px;">
+                    <button class="btn btn-primary" id="runCode">
+                        <i class="bi bi-play-fill"></i>
+                        运行
+                    </button>
+                    <button class="btn btn-danger" id="stopCode" style="display: none;">
+                        <i class="bi bi-stop-fill"></i>
+                        停止
+                    </button>
+                    <button class="btn btn-secondary" id="clearCode">
+                        <i class="bi bi-trash"></i>
+                        清除
+                    </button>
+                </div>
+            </div>
+            <div class="editor-content">
+                <div class="line-numbers" id="lineNumbers">1</div>
+                <div class="code-area" id="codeArea">
+                    <pre><code class="language-python" contenteditable="true" spellcheck="false" autocorrect="off" autocapitalize="off"># 您的代码将在这里显示</code></pre>
+                </div>
+            </div>
+        </div>
+        
+        <div class="section">
+            <div class="section-header">
+                <div class="section-title">
+                    <i class="bi bi-terminal"></i>
+                    终端输出
+                </div>
+                <div style="display: flex; gap: 8px;">
+                    <button class="btn btn-secondary" id="clearTerminal">
+                        <i class="bi bi-eraser"></i>
+                        清除
+                    </button>
+                </div>
+            </div>
+            <div class="output-content">
+                <div class="terminal-window">
+                    <pre id="output"></pre>
+                </div>
+                <div class="console-input-container" id="consoleInputContainer" style="display: none;">
+                    <div class="console-prompt">>></div>
+                    <input type="text" id="consoleInput" class="console-input" autocomplete="off" spellcheck="false" />
+                </div>
+            </div>
+        </div>
+    </div>
+    
+    <script>
+        document.addEventListener('DOMContentLoaded', () => {
+            // Terminal elements
+            const terminalOutput = document.getElementById('output');
+            const consoleInputContainer = document.getElementById('consoleInputContainer');
+            const consoleInput = document.getElementById('consoleInput');
+            const clearTerminalBtn = document.getElementById('clearTerminal');
+            const stopCodeBtn = document.getElementById('stopCode');
+            
+            // Editor elements
+            const codeArea = document.querySelector('#codeArea code');
+            const lineNumbers = document.getElementById('lineNumbers');
+            const runButton = document.getElementById('runCode');
+            const clearButton = document.getElementById('clearCode');
+            
+            // State variables
+            let executionContext = null;
+            let isExecuting = false;
+            let executionStartTime = null;
+            
+            // Initialize terminal
+            initializeTerminal();
+            
+            // Initialize editor
+            updateLineNumbers();
+            
+            // Function to update line numbers
+            function updateLineNumbers() {
+                const lines = codeArea.textContent.split('\n').length;
+                lineNumbers.innerHTML = Array.from({length: lines}, (_, i) => i + 1).join('<br>');
+            }
+            
+            // Initialize terminal with welcome message
+            function initializeTerminal() {
+                clearTerminalOutput();
+                appendToTerminal("欢迎使用Python交互式终端", "term-system");
+                appendToTerminal("使用'运行'按钮执行您的代码", "term-system");
+                appendToTerminal("", "term-system"); // 空行
+                appendToTerminal(">>> 准备执行代码...", "term-system");
+            }
+            
+            // Append text to terminal
+            function appendToTerminal(text, type = null) {
+                const lines = text.split('\n');
+                let html = '';
+                
+                for (const line of lines) {
+                    if (type) {
+                        html += `<span class="${type}">${escapeHtml(line)}</span>\n`;
+                    } else {
+                        html += escapeHtml(line) + '\n';
+                    }
+                }
+                
+                terminalOutput.innerHTML += html;
+                terminalOutput.scrollTop = terminalOutput.scrollHeight;
+            }
+            
+            // Clear terminal output
+            function clearTerminalOutput() {
+                terminalOutput.innerHTML = '';
+            }
+            
+            // Escape HTML to prevent XSS
+            function escapeHtml(text) {
+                return text
+                    .replace(/&/g, "&amp;")
+                    .replace(/</g, "&lt;")
+                    .replace(/>/g, "&gt;")
+                    .replace(/"/g, "&quot;")
+                    .replace(/'/g, "&#039;");
+            }
+            
+            // Run code
+            runButton.addEventListener('click', async () => {
+                if (isExecuting) return; // Prevent multiple executions
+                
+                const code = codeArea.textContent;
+                
+                // Clear terminal and show execution start
+                clearTerminalOutput();
+                appendToTerminal("开始执行Python代码...", "term-system");
+                
+                // Update UI state
+                isExecuting = true;
+                executionStartTime = performance.now();
+                runButton.style.display = 'none';
+                stopCodeBtn.style.display = 'flex';
+                
+                try {
+                    const response = await fetch('/api/code/execute', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ code })
+                    });
+                    
+                    const data = await response.json();
+                    
+                    if (data.success) {
+                        // Show output (if any)
+                        if (data.output && data.output.trim()) {
+                            appendToTerminal(data.output, "term-output");
+                        }
+                        
+                        if (data.needsInput) {
+                            // Code is waiting for input
+                            executionContext = data.context_id;
+                            consoleInputContainer.style.display = 'flex';
+                            consoleInput.focus();
+                        } else {
+                            // Code has completed, no input needed
+                            appendToTerminal("程序执行完成", "term-system");
+                            finishExecution();
+                        }
+                    } else {
+                        // Handle error
+                        appendToTerminal(`错误: ${data.error}`, "term-error");
+                        if (data.traceback) {
+                            appendToTerminal(data.traceback, "term-error");
+                        }
+                        appendToTerminal("执行失败", "term-system");
+                        finishExecution();
+                    }
+                } catch (error) {
+                    appendToTerminal(`系统错误: ${error.message}`, "term-error");
+                    appendToTerminal("执行失败", "term-system");
+                    finishExecution();
+                }
+            });
+            
+            // Submit console input
+            consoleInput.addEventListener('keydown', async (e) => {
+                if (e.key === 'Enter' && executionContext) {
+                    const input = consoleInput.value;
+                    consoleInput.value = '';
+                    
+                    // Add input to terminal
+                    appendToTerminal(`>> ${input}`, "term-input");
+                    
+                    try {
+                        // Send input to backend
+                        const response = await fetch('/api/code/input', {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({
+                                input: input,
+                                context_id: executionContext
+                            })
+                        });
+                        
+                        const data = await response.json();
+                        
+                        if (data.success) {
+                            // Show new output
+                            if (data.output && data.output.trim()) {
+                                appendToTerminal(data.output, "term-output");
+                            }
+                            
+                            if (data.needsInput) {
+                                // Still waiting for more input
+                                consoleInput.focus();
+                            } else {
+                                // Execution completed
+                                appendToTerminal(">>> 程序执行完成", "term-system");
+                                finishExecution();
+                            }
+                        } else {
+                            // Handle error
+                            appendToTerminal(`错误: ${data.error}`, "term-error");
+                            if (data.traceback) {
+                                appendToTerminal(data.traceback, "term-error");
+                            }
+                            finishExecution();
+                        }
+                    } catch (error) {
+                        appendToTerminal(`系统错误: ${error.message}`, "term-error");
+                        finishExecution();
+                    }
+                }
+            });
+            
+            // Stop code execution
+            stopCodeBtn.addEventListener('click', async () => {
+                if (!executionContext) return;
+                
+                try {
+                    // Send stop request to server
+                    const response = await fetch('/api/code/stop', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ context_id: executionContext })
+                    });
+                    
+                    // Clean up UI regardless of response
+                    appendToTerminal("用户终止了执行", "term-warning");
+                    finishExecution();
+                } catch (error) {
+                    console.error('停止执行时出错:', error);
+                    finishExecution();
+                }
+            });
+            
+            // Clear code
+            clearButton.addEventListener('click', () => {
+                codeArea.textContent = '# 您的代码将在这里显示';
+                updateLineNumbers();
+                clearTerminalOutput();
+                initializeTerminal();
+                consoleInputContainer.style.display = 'none';
+                executionContext = null;
+                isExecuting = false;
+                runButton.style.display = 'flex';
+                stopCodeBtn.style.display = 'none';
+            });
+            
+            // Clear terminal
+            clearTerminalBtn.addEventListener('click', () => {
+                if (!isExecuting) {
+                    clearTerminalOutput();
+                    initializeTerminal();
+                } else {
+                    // If execution is in progress, just add a separator
+                    appendToTerminal("\n--- 已清除终端 ---\n", "term-system");
+                }
+            });
+            
+            // Update line numbers on code changes
+            codeArea.addEventListener('input', updateLineNumbers);
+            
+            // Handle tab key
+            codeArea.addEventListener('keydown', (e) => {
+                if (e.key === 'Tab') {
+                    e.preventDefault();
+                    document.execCommand('insertText', false, '    ');
+                }
+            });
+            
+            // Function to clean up after execution completes
+            function finishExecution() {
+                consoleInputContainer.style.display = 'none';
+                executionContext = null;
+                isExecuting = false;
+                runButton.style.display = 'flex';
+                stopCodeBtn.style.display = 'none';
+            }
+            
+            // Check if code was provided via URL parameters
+            const urlParams = new URLSearchParams(window.location.search);
+            const initialCode = urlParams.get('code');
+            if (initialCode) {
+                try {
+                    codeArea.textContent = decodeURIComponent(initialCode);
+                    updateLineNumbers();
+                } catch (e) {
+                    console.error('Failed to decode initial code:', e);
+                }
+            }
+            
+            // Check for messages from parent frame
+            window.addEventListener('message', (event) => {
+                if (event.data && event.data.type === 'setCode') {
+                    codeArea.textContent = event.data.code;
+                    updateLineNumbers();
+                }
+            });
+        });
+    </script>
+</body>
+</html>

templates/index.html

@@ -0,0 +1,2362 @@
+<!-- templates/index.html -->
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+   <meta charset="UTF-8">
+   <meta name="viewport" content="width=device-width, initial-scale=1.0">
+   <title>教育AI助手开发平台</title>
+   <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css">
+   <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/[email protected]/font/bootstrap-icons.css">
+   <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js"></script>
+   <script src="https://cdnjs.cloudflare.com/ajax/libs/jsPlumb/2.15.6/js/jsplumb.min.js"></script>
+   <style>
+       :root {
+           --primary-color: #4361ee;
+           --secondary-color: #3f37c9;
+           --accent-color: #4cc9f0;
+           --success-color: #4caf50;
+           --warning-color: #ff9800;
+           --danger-color: #f44336;
+           --light-color: #f8f9fa;
+           --dark-color: #212529;
+           --border-color: #dee2e6;
+           --border-radius: 0.375rem;
+       }
+       
+       body {
+           font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+           display: flex;
+           margin: 0;
+           padding: 0;
+           height: 100vh;
+           background-color: #f5f7fa;
+           color: #333;
+       }
+       
+       .sidebar {
+           width: 280px;
+           background-color: #fff;
+           border-right: 1px solid var(--border-color);
+           box-shadow: 2px 0 5px rgba(0, 0, 0, 0.05);
+           display: flex;
+           flex-direction: column;
+           transition: all 0.3s ease;
+           z-index: 1000;
+       }
+       
+       .sidebar-header {
+           padding: 1.5rem;
+           border-bottom: 1px solid var(--border-color);
+       }
+       
+       .sidebar-header h2 {
+           margin: 0;
+           font-size: 1.5rem;
+           font-weight: 600;
+           color: var(--primary-color);
+       }
+       
+       .sidebar-menu {
+           list-style: none;
+           padding: 0;
+           margin: 0;
+           flex: 1;
+           overflow-y: auto;
+       }
+       
+       .sidebar-menu li {
+           padding: 1rem 1.5rem;
+           cursor: pointer;
+           transition: background-color 0.2s ease;
+           display: flex;
+           align-items: center;
+           position: relative;
+       }
+       
+       .sidebar-menu li i {
+           margin-right: 0.75rem;
+           font-size: 1.1rem;
+       }
+       
+       .sidebar-menu li:hover {
+           background-color: rgba(67, 97, 238, 0.05);
+           color: var(--primary-color);
+       }
+       
+       .sidebar-menu li.active {
+           background-color: rgba(67, 97, 238, 0.1);
+           color: var(--primary-color);
+           font-weight: 500;
+       }
+       
+       .sidebar-menu li.active::before {
+           content: '';
+           position: absolute;
+           left: 0;
+           top: 0;
+           bottom: 0;
+           width: 4px;
+           background-color: var(--primary-color);
+       }
+       
+       .main-content {
+           flex: 1;
+           padding: 2rem;
+           overflow-y: auto;
+       }
+       
+       .content-header {
+           margin-bottom: 2rem;
+       }
+       
+       .content-header h1 {
+           margin: 0;
+           font-size: 1.75rem;
+           font-weight: 600;
+           color: #333;
+       }
+       
+       .content-section {
+           display: none;
+       }
+       
+       .content-section.active {
+           display: block;
+       }
+       
+       .card {
+           background-color: #fff;
+           border-radius: var(--border-radius);
+           box-shadow: 0 2px 5px rgba(0, 0, 0, 0.05);
+           margin-bottom: 1.5rem;
+           border: 1px solid var(--border-color);
+          overflow: hidden;
+      }
+      
+      .card-header {
+          background-color: #fff;
+          border-bottom: 1px solid var(--border-color);
+          padding: 1rem 1.5rem;
+          display: flex;
+          justify-content: space-between;
+          align-items: center;
+      }
+      
+      .card-header h3 {
+          margin: 0;
+          font-size: 1.2rem;
+          font-weight: 600;
+      }
+      
+      .card-body {
+          padding: 1.5rem;
+      }
+      
+      .form-group {
+          margin-bottom: 1.5rem;
+      }
+      
+      .form-label {
+          font-weight: 500;
+          margin-bottom: 0.5rem;
+          display: block;
+      }
+      
+      .form-control {
+          border-radius: var(--border-radius);
+      }
+      
+      .btn {
+          border-radius: var(--border-radius);
+          font-weight: 500;
+      }
+      
+      .btn-primary {
+          background-color: var(--primary-color);
+          border-color: var(--primary-color);
+      }
+      
+      .btn-primary:hover {
+          background-color: var(--secondary-color);
+          border-color: var(--secondary-color);
+      }
+      
+      .workflow-editor {
+          border: 1px solid var(--border-color);
+          border-radius: var(--border-radius);
+          min-height: 400px;
+          background-color: #f8f9fa;
+          position: relative;
+      }
+      
+      .knowledge-item {
+          padding: 1rem;
+          margin-bottom: 1rem;
+          border: 1px solid var(--border-color);
+          border-radius: var(--border-radius);
+          background-color: #fff;
+          transition: all 0.2s ease;
+      }
+      
+      .knowledge-item:hover {
+          box-shadow: 0 5px 15px rgba(0, 0, 0, 0.08);
+      }
+      
+      .knowledge-item .header {
+          display: flex;
+          justify-content: space-between;
+          align-items: center;
+          margin-bottom: 0.5rem;
+      }
+      
+      .agent-item {
+          padding: 1.25rem;
+          margin-bottom: 1.5rem;
+          border-radius: var(--border-radius);
+          background-color: #fff;
+          box-shadow: 0 2px 10px rgba(0, 0, 0, 0.05);
+          transition: all 0.2s ease;
+          border-left: 4px solid var(--primary-color);
+      }
+      
+      .agent-item:hover {
+          box-shadow: 0 5px 15px rgba(0, 0, 0, 0.1);
+          transform: translateY(-2px);
+      }
+      
+      .agent-item .header {
+          display: flex;
+          justify-content: space-between;
+          align-items: center;
+          margin-bottom: 1rem;
+      }
+      
+      .agent-item .title {
+          font-size: 1.2rem;
+          font-weight: 600;
+          margin: 0;
+          color: #333;
+      }
+      
+      .agent-item .description {
+          color: #666;
+          margin-bottom: 1rem;
+      }
+      
+      .agent-item .meta {
+          display: flex;
+          font-size: 0.85rem;
+          color: #777;
+          margin-top: 1rem;
+      }
+      
+      .agent-item .meta div {
+          margin-right: 1.5rem;
+          display: flex;
+          align-items: center;
+      }
+      
+      .agent-item .meta i {
+          margin-right: 0.5rem;
+      }
+      
+      .nav-tabs {
+          border-bottom: 1px solid var(--border-color);
+          margin-bottom: 1.5rem;
+      }
+      
+      .nav-tabs .nav-link {
+          margin-bottom: -1px;
+          border: 1px solid transparent;
+          border-top-left-radius: 0.375rem;
+          border-top-right-radius: 0.375rem;
+          padding: 0.75rem 1.25rem;
+          color: #495057;
+      }
+      
+      .nav-tabs .nav-link.active {
+          color: var(--primary-color);
+          background-color: #fff;
+          border-color: var(--border-color) var(--border-color) #fff;
+          font-weight: 500;
+      }
+      
+      .nav-tabs .nav-link:hover {
+          border-color: #e9ecef #e9ecef var(--border-color);
+      }
+      
+      .spinner-border {
+          width: 1.5rem;
+          height: 1.5rem;
+      }
+      
+      .distribution-link {
+          padding: 0.75rem 1rem;
+          background-color: #f8f9fa;
+          border: 1px solid var(--border-color);
+          border-radius: var(--border-radius);
+          display: flex;
+          justify-content: space-between;
+          align-items: center;
+          margin-bottom: 1rem;
+      }
+      
+      .badge {
+          display: inline-block;
+          padding: 0.35em 0.65em;
+          font-size: 0.75em;
+          font-weight: 500;
+          line-height: 1;
+          text-align: center;
+          white-space: nowrap;
+          vertical-align: baseline;
+          border-radius: 50rem;
+          margin-left: 0.5rem;
+      }
+      
+      .badge-primary {
+          background-color: var(--primary-color);
+          color: #fff;
+      }
+      
+      .badge-success {
+          background-color: var(--success-color);
+          color: #fff;
+      }
+      
+      .badge-warning {
+          background-color: var(--warning-color);
+          color: #fff;
+      }
+      
+      .plugin-option {
+          padding: 1rem;
+          margin-bottom: 1rem;
+          border: 1px solid var(--border-color);
+          border-radius: var(--border-radius);
+          display: flex;
+          align-items: center;
+          cursor: pointer;
+          transition: all 0.2s ease;
+      }
+      
+      .plugin-option:hover {
+          background-color: rgba(67, 97, 238, 0.05);
+          border-color: var(--primary-color);
+      }
+      
+      .plugin-option.selected {
+          background-color: rgba(67, 97, 238, 0.1);
+          border-color: var(--primary-color);
+      }
+      
+      .plugin-option .icon {
+          font-size: 1.5rem;
+          margin-right: 1rem;
+          color: var(--primary-color);
+      }
+      
+      .plugin-option .content {
+          flex: 1;
+      }
+      
+      .plugin-option .title {
+          font-weight: 500;
+          margin-bottom: 0.25rem;
+      }
+      
+      .plugin-option .description {
+          font-size: 0.9rem;
+          color: #666;
+      }
+
+      /* 工作流可视化相关样式 */
+      .workflow-canvas {
+          height: 400px;
+          background-color: #f9fbfd;
+          border: 1px solid var(--border-color);
+          border-radius: var(--border-radius);
+          position: relative;
+      }
+      
+      /* 工作流节点样式 */
+      .workflow-node {
+          position: absolute;
+          width: 150px;
+          height: 50px;
+          background-color: white;
+          border-radius: 4px;
+          border: 1px solid #ccc;
+          box-shadow: 0 2px 6px rgba(0,0,0,0.1);
+          display: flex;
+          overflow: hidden;
+          user-select: none;
+          z-index: 10;
+      }
+      
+      .node-icon {
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          width: 30px;
+          height: 100%;
+          color: white;
+          font-weight: bold;
+      }
+      
+      .node-content {
+          flex: 1;
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          padding: 0 10px;
+          font-size: 14px;
+          color: #333;
+      }
+      
+      /* 节点类型样式 */
+      .node-type-intent_recognition .node-icon {
+          background-color: #673AB7;
+      }
+      .node-type-intent_recognition {
+          border-color: #673AB7;
+          background-color: #EDE7F6;
+      }
+      
+      .node-type-knowledge_query .node-icon {
+          background-color: #009688;
+      }
+      .node-type-knowledge_query {
+          border-color: #009688;
+          background-color: #E0F2F1;
+      }
+      
+      .node-type-plugin_call .node-icon {
+          background-color: #FF9800;
+      }
+      .node-type-plugin_call {
+          border-color: #FF9800;
+          background-color: #FFF3E0;
+      }
+      
+      .node-type-generate_response .node-icon {
+          background-color: #2196F3;
+      }
+      .node-type-generate_response {
+          border-color: #2196F3;
+          background-color: #E3F2FD;
+      }
+      
+      /* jsPlumb 连接线标签样式 */
+      .connection-label {
+          background-color: white;
+          padding: 3px 6px;
+          border-radius: 3px;
+          border: 1px solid #eee;
+          font-size: 12px;
+          color: #666;
+      }
+  </style>
+</head>
+<body>
+  <div class="sidebar">
+      <div class="sidebar-header">
+          <h2>AI助教开发平台</h2>
+      </div>
+      <ul class="sidebar-menu">
+          <li class="active" data-section="dashboard">
+              <i class="bi bi-grid-1x2"></i>
+              <span>仪表盘</span>
+          </li>
+          <li data-section="create-agent">
+              <i class="bi bi-plus-circle"></i>
+              <span>创建Agent</span>
+          </li>
+          <li data-section="knowledge-base">
+              <i class="bi bi-database"></i>
+              <span>知识库管理</span>
+          </li>
+          <li data-section="agent-list">
+              <i class="bi bi-list-ul"></i>
+              <span>Agent列表</span>
+          </li>
+      </ul>
+  </div>
+  
+  <div class="main-content">
+      <!-- 仪表盘 -->
+      <section id="dashboard" class="content-section active">
+          <div class="content-header">
+              <h1>仪表盘</h1>
+              <p class="text-muted mt-2">欢迎使用教育AI助手开发平台</p>
+          </div>
+          
+          <div class="row">
+              <div class="col-md-4">
+                  <div class="card">
+                      <div class="card-body text-center">
+                          <div class="display-4 mb-3">
+                              <i class="bi bi-robot text-primary"></i>
+                          </div>
+                          <h3 id="agent-count">0</h3>
+                          <p class="text-muted">AI助手</p>
+                      </div>
+                  </div>
+              </div>
+              <div class="col-md-4">
+                  <div class="card">
+                      <div class="card-body text-center">
+                          <div class="display-4 mb-3">
+                              <i class="bi bi-database text-success"></i>
+                          </div>
+                          <h3 id="knowledge-count">0</h3>
+                          <p class="text-muted">知识库</p>
+                      </div>
+                  </div>
+              </div>
+              <div class="col-md-4">
+                  <div class="card">
+                      <div class="card-body text-center">
+                          <div class="display-4 mb-3">
+                              <i class="bi bi-share text-warning"></i>
+                          </div>
+                          <h3 id="distribution-count">0</h3>
+                          <p class="text-muted">分发链接</p>
+                      </div>
+                  </div>
+              </div>
+          </div>
+          
+          <div class="row mt-4">
+              <div class="col-md-6">
+                  <div class="card">
+                      <div class="card-header">
+                          <h3>最近创建的Agent</h3>
+                      </div>
+                      <div class="card-body" id="recent-agents">
+                          <div class="text-center py-4">
+                              <div class="spinner-border text-primary" role="status">
+                                  <span class="visually-hidden">加载中...</span>
+                              </div>
+                          </div>
+                      </div>
+                  </div>
+              </div>
+              <div class="col-md-6">
+                  <div class="card">
+                      <div class="card-header">
+                          <h3>快速入门</h3>
+                      </div>
+                      <div class="card-body">
+                          <div class="quick-start-item mb-3 p-3 border-bottom">
+                              <h5><i class="bi bi-1-circle me-2"></i> 创建知识库</h5>
+                              <p>上传PDF、文本等文档，构建AI助手的知识基础。</p>
+                              <button class="btn btn-sm btn-outline-primary" onclick="switchSection('knowledge-base')">开始创建</button>
+                          </div>
+                          <div class="quick-start-item mb-3 p-3 border-bottom">
+                              <h5><i class="bi bi-2-circle me-2"></i> 创建Agent</h5>
+                              <p>设计您的AI助手，选择插件和知识库。</p>
+                              <button class="btn btn-sm btn-outline-primary" onclick="switchSection('create-agent')">开始创建</button>
+                          </div>
+                          <div class="quick-start-item p-3">
+                              <h5><i class="bi bi-3-circle me-2"></i> 分发给学生</h5>
+                              <p>生成访问链接，分享给您的学生。</p>
+                              <button class="btn btn-sm btn-outline-primary" onclick="switchSection('agent-list')">查看Agent</button>
+                          </div>
+                      </div>
+                  </div>
+              </div>
+          </div>
+      </section>
+      
+      <!-- 创建Agent -->
+      <section id="create-agent" class="content-section">
+          <div class="content-header">
+              <h1>创建新Agent</h1>
+              <p class="text-muted mt-2">设计您的AI助教Agent</p>
+          </div>
+          
+          <div class="card">
+              <div class="card-body">
+                  <ul class="nav nav-tabs" id="agentCreationTabs" role="tablist">
+                      <li class="nav-item" role="presentation">
+                          <button class="nav-link active" id="basic-tab" data-bs-toggle="tab" data-bs-target="#basic" type="button" role="tab" aria-controls="basic" aria-selected="true">基本信息</button>
+                      </li>
+                      <li class="nav-item" role="presentation">
+                          <button class="nav-link" id="plugins-tab" data-bs-toggle="tab" data-bs-target="#plugins" type="button" role="tab" aria-controls="plugins" aria-selected="false">插件选择</button>
+                      </li>
+                      <li class="nav-item" role="presentation">
+                          <button class="nav-link" id="knowledge-tab" data-bs-toggle="tab" data-bs-target="#knowledge" type="button" role="tab" aria-controls="knowledge" aria-selected="false">知识库</button>
+                      </li>
+                      <li class="nav-item" role="presentation">
+                          <button class="nav-link" id="workflow-tab" data-bs-toggle="tab" data-bs-target="#workflow" type="button" role="tab" aria-controls="workflow" aria-selected="false">工作流设计</button>
+                      </li>
+                  </ul>
+                  
+                  <div class="tab-content" id="agentCreationTabContent">
+                      <!-- 基本信息 -->
+                      <div class="tab-pane fade show active" id="basic" role="tabpanel" aria-labelledby="basic-tab">
+                          <div class="mt-4">
+                              <div class="form-group">
+                                  <label for="agent-name" class="form-label">Agent名称</label>
+                                  <input type="text" class="form-control" id="agent-name" placeholder="例如：计算机组成原理助教">
+                              </div>
+                              <div class="form-group">
+                                  <label for="agent-description" class="form-label">描述</label>
+                                  <textarea class="form-control" id="agent-description" rows="3" placeholder="描述这个Agent的功能和用途..."></textarea>
+                              </div>
+                              <div class="form-group">
+                                  <label for="agent-subject" class="form-label">学科/课程名称</label>
+                                  <input type="text" class="form-control" id="agent-subject" placeholder="例如：计算机组成原理">
+                                  <div class="form-text">这将影响AI助教的知识领域定位</div>
+                              </div>
+                              <div class="form-group">
+                                  <label for="agent-instructor" class="form-label">指导教师</label>
+                                  <input type="text" class="form-control" id="agent-instructor" placeholder="例如：李志刚教授">
+                              </div>
+                              <div class="form-group">
+                                  <label for="agent-type" class="form-label">Agent类型</label>
+                                  <select class="form-select" id="agent-type">
+                                      <option value="educational">教育辅导</option>
+                                      <option value="programming">编程辅助</option>
+                                      <option value="math">数学辅导</option>
+                                      <option value="general">通用助手</option>
+                                  </select>
+                              </div>
+                              <button class="btn btn-primary" onclick="nextTab('plugins-tab')">下一步</button>
+                          </div>
+                      </div>
+                      
+                      <!-- 插件选择 -->
+                      <div class="tab-pane fade" id="plugins" role="tabpanel" aria-labelledby="plugins-tab">
+                          <div class="mt-4">
+                              <div class="mb-3">
+                                  <h5>选择Agent所需的插件</h5>
+                                  <p class="text-muted">插件可以扩展Agent的能力，使其更加强大</p>
+                              </div>
+                              
+                              <div class="plugin-option" data-plugin="code" onclick="togglePluginSelection(this)">
+                                  <div class="icon">
+                                      <i class="bi bi-code-square"></i>
+                                  </div>
+                                  <div class="content">
+                                      <div class="title">代码执行</div>
+                                      <div class="description">允许学生编写和执行Python代码，实时获取结果</div>
+                                  </div>
+                                  <div class="checkbox">
+                                      <input type="checkbox" class="form-check-input">
+                                  </div>
+                              </div>
+                              
+                              <div class="plugin-option" data-plugin="visualization" onclick="togglePluginSelection(this)">
+                                  <div class="icon">
+                                      <i class="bi bi-bar-chart"></i>
+                                  </div>
+                                  <div class="content">
+                                      <div class="title">3D可视化</div>
+                                      <div class="description">生成交互式3D图形，帮助学生理解数学概念</div>
+                                  </div>
+                                  <div class="checkbox">
+                                      <input type="checkbox" class="form-check-input">
+                                  </div>
+                              </div>
+                              
+                              <div class="plugin-option" data-plugin="mindmap" onclick="togglePluginSelection(this)">
+                                  <div class="icon">
+                                      <i class="bi bi-diagram-3"></i>
+                                  </div>
+                                  <div class="content">
+                                      <div class="title">思维导图</div>
+                                      <div class="description">创建结构化的思维导图，帮助学生梳理知识点</div>
+                                  </div>
+                                  <div class="checkbox">
+                                      <input type="checkbox" class="form-check-input">
+                                  </div>
+                              </div>
+                              
+                              <div class="d-flex justify-content-between mt-4">
+                                  <button class="btn btn-outline-secondary" onclick="nextTab('basic-tab')">上一步</button>
+                                  <button class="btn btn-primary" onclick="nextTab('knowledge-tab')">下一步</button>
+                              </div>
+                          </div>
+                      </div>
+                      
+                      <!-- 知识库 -->
+                      <div class="tab-pane fade" id="knowledge" role="tabpanel" aria-labelledby="knowledge-tab">
+                          <div class="mt-4">
+                              <div class="mb-3">
+                                  <h5>选择Agent使用的知识库</h5>
+                                  <p class="text-muted">知识库提供Agent回答问题的专业知识</p>
+                              </div>
+                              
+                              <div class="mb-3">
+                                  <div class="input-group">
+                                      <input type="text" class="form-control" placeholder="搜索知识库..." id="knowledge-search">
+                                      <button class="btn btn-outline-secondary" type="button">
+                                          <i class="bi bi-search"></i>
+                                      </button>
+                                  </div>
+                              </div>
+                              
+                              <div id="knowledge-list" class="mb-4">
+                                  <div class="text-center py-4">
+                                      <div class="spinner-border text-primary" role="status">
+                                          <span class="visually-hidden">加载中...</span>
+                                      </div>
+                                  </div>
+                              </div>
+                              
+                              <div class="d-flex justify-content-between mt-4">
+                                  <button class="btn btn-outline-secondary" onclick="nextTab('plugins-tab')">上一步</button>
+                                  <button class="btn btn-primary" onclick="nextTab('workflow-tab')">下一步</button>
+                              </div>
+                          </div>
+                      </div>
+                      
+                      <!-- 工作流设计 -->
+                      <div class="tab-pane fade" id="workflow" role="tabpanel" aria-labelledby="workflow-tab">
+                          <div class="mt-4">
+                              <div class="mb-3">
+                                  <h5>设计Agent工作流</h5>
+                                  <p class="text-muted">定义Agent如何处理用户的请求</p>
+                              </div>
+                              
+                              <div class="mb-4">
+                                  <button class="btn btn-primary" id="ai-workflow-btn">
+                                      <i class="bi bi-magic"></i> 使用AI自动设计工作流
+                                  </button>
+                              </div>
+                              
+                              <div class="card mb-4">
+                                  <div class="card-body p-0">
+                                    <ul class="nav nav-tabs" id="workflowViewTabs" role="tablist">
+                                        <li class="nav-item" role="presentation">
+                                            <button class="nav-link active" id="visual-tab" data-bs-toggle="tab" data-bs-target="#visual-view" type="button" role="tab">可视化视图</button>
+                                        </li>
+                                        <li class="nav-item" role="presentation">
+                                            <button class="nav-link" id="code-tab" data-bs-toggle="tab" data-bs-target="#code-view" type="button" role="tab">代码视图</button>
+                                        </li>
+                                    </ul>
+                                    <div class="tab-content" id="workflowViewContent">
+                                        <div class="tab-pane fade show active" id="visual-view" role="tabpanel">
+                                            <div id="workflow-canvas" class="workflow-canvas">
+                                                <div class="p-4 text-center text-muted">
+                                                    点击"使用AI自动设计工作流"按钮，或手动设计工作流
+                                                </div>
+                                            </div>
+                                        </div>
+                                        <div class="tab-pane fade" id="code-view" role="tabpanel">
+                                            <div class="p-4">
+                                                <pre id="workflow-code" class="mb-0 p-3 bg-light border rounded">{}</pre>
+                                            </div>
+                                        </div>
+                                    </div>
+                                  </div>
+                              </div>
+                              
+                              <div class="d-flex justify-content-between">
+                                  <button class="btn btn-outline-secondary" onclick="nextTab('knowledge-tab')">上一步</button>
+                                  <button class="btn btn-success" id="create-agent-btn">创建Agent</button>
+                              </div>
+                          </div>
+                      </div>
+                  </div>
+              </div>
+          </div>
+      </section>
+      
+      <!-- 知识库管理 -->
+      <section id="knowledge-base" class="content-section">
+          <div class="content-header">
+              <h1>知识库管理</h1>
+              <p class="text-muted mt-2">上传和管理Agent的知识源</p>
+          </div>
+          
+          <div class="row">
+              <div class="col-md-4">
+                  <div class="card">
+                      <div class="card-header">
+                          <h3>创建知识库</h3>
+                      </div>
+                      <div class="card-body">
+                          <form id="knowledge-form">
+                              <div class="form-group">
+                                  <label for="knowledge-name" class="form-label">知识库名称</label>
+                                  <input type="text" class="form-control" id="knowledge-name" placeholder="例如：计算机组成原理" required>
+                              </div>
+                              
+                              <div class="form-group">
+                                  <label for="knowledge-file" class="form-label">上传文件</label>
+                                  <input type="file" class="form-control" id="knowledge-file" required>
+                                  <div class="form-text">支持PDF、TXT、MD等格式</div>
+                              </div>
+                              
+                              <div class="progress mt-3 mb-2" style="display: none;" id="upload-progress">
+                                  <div class="progress-bar progress-bar-striped progress-bar-animated" role="progressbar" style="width: 0%"></div>
+                              </div>
+                              
+                              <button type="submit" class="btn btn-primary mt-3 w-100">创建知识库</button>
+                          </form>
+                      </div>
+                  </div>
+              </div>
+              
+              <div class="col-md-8">
+                  <div class="card">
+                      <div class="card-header">
+                          <h3>现有知识库</h3>
+                      </div>
+                      <div class="card-body">
+                          <div id="existing-knowledge-list">
+                              <div class="text-center py-4">
+                                  <div class="spinner-border text-primary" role="status">
+                                      <span class="visually-hidden">加载中...</span>
+                                  </div>
+                              </div>
+                          </div>
+                      </div>
+                  </div>
+              </div>
+          </div>
+      </section>
+      
+      <!-- Agent列表 -->
+      <section id="agent-list" class="content-section">
+          <div class="content-header d-flex justify-content-between align-items-center">
+              <div>
+                  <h1>Agent列表</h1>
+                  <p class="text-muted mt-2">管理和分发您创建的AI助手</p>
+              </div>
+              <div>
+                  <button class="btn btn-primary" onclick="switchSection('create-agent')">
+                      <i class="bi bi-plus-lg"></i> 创建新Agent
+                  </button>
+              </div>
+          </div>
+          
+          <div class="row">
+              <div class="col-12">
+                  <div class="card">
+                      <div class="card-body">
+                          <div id="agent-list-container">
+                              <div class="text-center py-4">
+                                  <div class="spinner-border text-primary" role="status">
+                                      <span class="visually-hidden">加载中...</span>
+                                  </div>
+                              </div>
+                          </div>
+                      </div>
+                  </div>
+              </div>
+          </div>
+      </section>
+  </div>
+  
+  <!-- 模态框：Agent详情 -->
+  <div class="modal fade" id="agentDetailModal" tabindex="-1" aria-hidden="true">
+      <div class="modal-dialog modal-lg">
+          <div class="modal-content">
+              <div class="modal-header">
+                  <h5 class="modal-title" id="agent-detail-title">Agent详情</h5>
+                  <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+              </div>
+              <div class="modal-body" id="agent-detail-body">
+                <!-- Agent详情将通过JavaScript填充 -->
+            </div>
+            <div class="modal-footer">
+                <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">关闭</button>
+            </div>
+        </div>
+    </div>
+</div>
+
+<!-- 模态框：创建分发链接 -->
+<div class="modal fade" id="createDistributionModal" tabindex="-1" aria-hidden="true">
+    <div class="modal-dialog">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h5 class="modal-title">创建分发链接</h5>
+                <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+            </div>
+            <div class="modal-body">
+                <form id="distribution-form">
+                    <input type="hidden" id="distribution-agent-id">
+                    <div class="form-group mb-3">
+                        <label for="distribution-expires" class="form-label">链接有效期</label>
+                        <select class="form-select" id="distribution-expires">
+                            <option value="0">永不过期</option>
+                            <option value="86400">1天</option>
+                            <option value="604800">7天</option>
+                            <option value="2592000">30天</option>
+                        </select>
+                    </div>
+                </form>
+            </div>
+            <div class="modal-footer">
+                <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
+                <button type="button" class="btn btn-primary" id="create-distribution-btn">创建链接</button>
+            </div>
+        </div>
+    </div>
+</div>
+
+<!-- 模态框：显示分发链接 -->
+<div class="modal fade" id="showDistributionModal" tabindex="-1" aria-hidden="true">
+    <div class="modal-dialog">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h5 class="modal-title">分发链接</h5>
+                <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+            </div>
+            <div class="modal-body">
+                <div class="alert alert-success">
+                    链接创建成功！请复制以下链接分享给学生
+                </div>
+                <div class="input-group mb-3">
+                    <input type="text" class="form-control" id="distribution-link" readonly>
+                    <button class="btn btn-outline-secondary" type="button" onclick="copyToClipboard('distribution-link')">
+                        <i class="bi bi-clipboard"></i>
+                    </button>
+                </div>
+            </div>
+            <div class="modal-footer">
+                <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">关闭</button>
+            </div>
+        </div>
+    </div>
+</div>
+
+<script>
+    // 初始化变量
+let selectedPlugins = [];
+let selectedKnowledgeBases = [];
+let currentWorkflow = { nodes: [], edges: [] };
+let allKnowledgeBases = [];
+let allAgents = [];
+let jsPlumbWorkflowInstance = null; // 添加jsPlumb实例变量
+
+// 页面加载完成后执行
+document.addEventListener('DOMContentLoaded', function() {
+    // 初始化侧边栏菜单点击事件
+    document.querySelectorAll('.sidebar-menu li').forEach(item => {
+        item.addEventListener('click', function() {
+            const section = this.getAttribute('data-section');
+            switchSection(section);
+        });
+    });
+    
+    // 初始化表单提交事件
+    document.getElementById('knowledge-form').addEventListener('submit', createKnowledgeBase);
+    
+    // 初始化AI工作流按钮
+    document.getElementById('ai-workflow-btn').addEventListener('click', generateAIWorkflow);
+    
+    // 初始化创建Agent按钮
+    document.getElementById('create-agent-btn').addEventListener('click', createAgent);
+    
+    // 初始化创建分发链接按钮
+    document.getElementById('create-distribution-btn').addEventListener('click', createDistribution);
+    
+    // 初始化工作流视图标签切换
+    initWorkflowTabs();
+    
+    // 加载知识库列表
+    loadKnowledgeBases();
+    
+    // 加载Agent列表
+    loadAgents();
+});
+
+// 初始化工作流标签切换
+function initWorkflowTabs() {
+    // 为主工作流和详情工作流标签添加点击事件
+    document.querySelectorAll('#workflowViewTabs .nav-link, #detailWorkflowTabs .nav-link').forEach(tab => {
+        tab.addEventListener('click', function(event) {
+            event.preventDefault();
+            
+            // 获取目标面板ID
+            const targetId = this.getAttribute('data-bs-target');
+            const targetPane = document.querySelector(targetId);
+            
+            if (!targetPane) return;
+            
+            // 获取所有同级标签并移除激活状态
+            const tabs = this.closest('.nav-tabs').querySelectorAll('.nav-link');
+            tabs.forEach(t => t.classList.remove('active'));
+            
+            // 激活当前标签
+            this.classList.add('active');
+            
+            // 获取所有同级面板并隐藏
+            const tabContent = targetPane.closest('.tab-content');
+            if (tabContent) {
+                tabContent.querySelectorAll('.tab-pane').forEach(pane => {
+                    pane.classList.remove('show', 'active');
+                });
+            }
+            
+            // 显示目标面板
+            targetPane.classList.add('show', 'active');
+            
+            // 如果切换到可视化视图，重新渲染工作流
+            if (targetId === '#visual-view' || targetId === '#detail-visual-view') {
+                const canvasId = targetId === '#visual-view' ? 'workflow-canvas' : 'detail-workflow-canvas';
+                
+                // 确定要使用的工作流数据
+                let workflowData = currentWorkflow;
+                if (targetId === '#detail-visual-view') {
+                    const modalBody = document.getElementById('agent-detail-body');
+                    if (modalBody && modalBody.dataset.agentWorkflow) {
+                        try {
+                            workflowData = JSON.parse(modalBody.dataset.agentWorkflow);
+                        } catch (e) {
+                            console.error('解析工作流数据出错:', e);
+                        }
+                    }
+                }
+                
+                // 延迟一小段时间确保DOM已经更新
+                setTimeout(() => {
+                    renderWorkflowVisualization(workflowData, canvasId);
+                }, 200);
+            }
+        });
+    });
+}
+
+// 切换内容区域
+function switchSection(section) {
+    // 隐藏所有内容区域
+    document.querySelectorAll('.content-section').forEach(item => {
+        item.classList.remove('active');
+    });
+    
+    // 显示选中的内容区域
+    document.getElementById(section).classList.add('active');
+    
+    // 更新侧边栏选中状态
+    document.querySelectorAll('.sidebar-menu li').forEach(item => {
+        item.classList.remove('active');
+        if (item.getAttribute('data-section') === section) {
+            item.classList.add('active');
+        }
+    });
+    
+    // 如果切换到了工作流视图，重新绘制连接
+    if (section === 'create-agent') {
+        // 获取当前激活的标签页
+        const activeTab = document.querySelector('#agentCreationTabs .nav-link.active');
+        if (activeTab && activeTab.id === 'workflow-tab') {
+            // 检查当前哪个视图处于激活状态
+            const activeView = document.querySelector('#workflowViewContent .tab-pane.active');
+            if (activeView && activeView.id === 'visual-view') {
+                // 延迟执行以确保DOM已更新
+                setTimeout(() => {
+                    renderWorkflowVisualization(currentWorkflow, 'workflow-canvas');
+                }, 200);
+            }
+        }
+    }
+}
+
+// 切换到下一个选项卡
+function nextTab(tabId) {
+    const tab = document.getElementById(tabId);
+    const bsTab = new bootstrap.Tab(tab);
+    bsTab.show();
+}
+
+// 切换插件选择状态
+function togglePluginSelection(element) {
+    const pluginId = element.getAttribute('data-plugin');
+    const checkbox = element.querySelector('input[type="checkbox"]');
+    
+    if (element.classList.contains('selected')) {
+        element.classList.remove('selected');
+        checkbox.checked = false;
+        selectedPlugins = selectedPlugins.filter(id => id !== pluginId);
+    } else {
+        element.classList.add('selected');
+        checkbox.checked = true;
+        selectedPlugins.push(pluginId);
+    }
+}
+
+// 切换知识库选择状态
+function toggleKnowledgeSelection(element) {
+    const knowledgeId = element.getAttribute('data-id');
+    
+    if (element.classList.contains('selected')) {
+        element.classList.remove('selected');
+        element.querySelector('input[type="checkbox"]').checked = false;
+        selectedKnowledgeBases = selectedKnowledgeBases.filter(id => id !== knowledgeId);
+    } else {
+        element.classList.add('selected');
+        element.querySelector('input[type="checkbox"]').checked = true;
+        selectedKnowledgeBases.push(knowledgeId);
+    }
+}
+
+// 加载知识库列表
+async function loadKnowledgeBases() {
+    try {
+        const response = await fetch('/api/knowledge');
+        const result = await response.json();
+        
+        if (result.success) {
+            allKnowledgeBases = result.data || [];
+            
+            // 更新仪表盘计数
+            document.getElementById('knowledge-count').textContent = allKnowledgeBases.length;
+            
+            // 更新Agent创建页面的知识库列表
+            const knowledgeListElement = document.getElementById('knowledge-list');
+            if (knowledgeListElement) {
+                if (allKnowledgeBases.length === 0) {
+                    knowledgeListElement.innerHTML = `
+                        <div class="alert alert-info">
+                            <i class="bi bi-info-circle me-2"></i>
+                            暂无知识库，请先创建知识库
+                        </div>
+                        <div class="text-center">
+                            <button class="btn btn-primary" onclick="switchSection('knowledge-base')">
+                                创建知识库
+                            </button>
+                        </div>
+                    `;
+                } else {
+                    knowledgeListElement.innerHTML = '';
+                    
+                    allKnowledgeBases.forEach(knowledge => {
+                        const item = document.createElement('div');
+                        item.className = 'plugin-option';
+                        item.setAttribute('data-id', knowledge.id);
+                        item.setAttribute('onclick', 'toggleKnowledgeSelection(this)');
+                        
+                        item.innerHTML = `
+                            <div class="icon">
+                                <i class="bi bi-journal-text"></i>
+                            </div>
+                            <div class="content">
+                                <div class="title">${knowledge.name}</div>
+                                <div class="description">
+                                    <small>${knowledge.fileCount}个文件</small>
+                                </div>
+                            </div>
+                            <div class="checkbox">
+                                <input type="checkbox" class="form-check-input">
+                            </div>
+                        `;
+                        
+                        knowledgeListElement.appendChild(item);
+                    });
+                }
+            }
+            
+            // 更新知识库管理页面的列表
+            const existingKnowledgeList = document.getElementById('existing-knowledge-list');
+            if (existingKnowledgeList) {
+                if (allKnowledgeBases.length === 0) {
+                    existingKnowledgeList.innerHTML = `
+                        <div class="alert alert-info">
+                            <i class="bi bi-info-circle me-2"></i>
+                            暂无知识库，请创建第一个知识库
+                        </div>
+                    `;
+                } else {
+                    existingKnowledgeList.innerHTML = '';
+                    
+                    allKnowledgeBases.forEach(knowledge => {
+                        const item = document.createElement('div');
+                        item.className = 'knowledge-item';
+                        
+                        let fileListHtml = '';
+                        if (knowledge.files && knowledge.files.length > 0) {
+                            fileListHtml = '<div class="mt-3"><small class="text-muted">包含文件：</small><ul class="list-unstyled ms-3">';
+                            knowledge.files.forEach(file => {
+                                fileListHtml += `<li><small><i class="bi bi-file-text me-1"></i>${file}</small></li>`;
+                            });
+                            fileListHtml += '</ul></div>';
+                        }
+                        
+                        item.innerHTML = `
+                            <div class="header">
+                                <h5>${knowledge.name}</h5>
+                                <div>
+                                    <button class="btn btn-sm btn-outline-danger" onclick="deleteKnowledgeBase('${knowledge.id}')">
+                                        <i class="bi bi-trash"></i>
+                                    </button>
+                                </div>
+                            </div>
+                            <div>
+                                <span class="badge bg-primary">${knowledge.fileCount}个文件</span>
+                            </div>
+                            ${fileListHtml}
+                            <div class="mt-3">
+                                <form class="upload-form" data-id="${knowledge.id}">
+                                    <div class="input-group">
+                                        <input type="file" class="form-control form-control-sm" required>
+                                        <button type="submit" class="btn btn-sm btn-outline-primary">添加文件</button>
+                                    </div>
+                                </form>
+                            </div>
+                        `;
+                        
+                        existingKnowledgeList.appendChild(item);
+                    });
+                    
+                    // 添加上传表单事件监听
+                    document.querySelectorAll('.upload-form').forEach(form => {
+                        form.addEventListener('submit', function(event) {
+                            event.preventDefault();
+                            addFileToKnowledgeBase(form);
+                        });
+                    });
+                }
+            }
+        } else {
+            console.error('加载知识库失败:', result.message);
+        }
+    } catch (error) {
+        console.error('加载知识库出错:', error);
+    }
+}
+
+// 创建知识库
+async function createKnowledgeBase(event) {
+    event.preventDefault();
+    
+    const nameInput = document.getElementById('knowledge-name');
+    const fileInput = document.getElementById('knowledge-file');
+    const progressBar = document.getElementById('upload-progress');
+    
+    if (!nameInput.value || !fileInput.files[0]) {
+        alert('请填写知识库名称并选择文件');
+        return;
+    }
+    
+    // 显示进度条
+    progressBar.style.display = 'block';
+    progressBar.querySelector('.progress-bar').style.width = '0%';
+    
+    const formData = new FormData();
+    formData.append('name', nameInput.value);
+    formData.append('file', fileInput.files[0]);
+    
+    try {
+        const response = await fetch('/api/knowledge', {
+            method: 'POST',
+            body: formData
+        });
+        
+        const result = await response.json();
+        
+        if (result.success) {
+            // 成功启动处理，轮询进度
+            pollProgress(result.task_id, progressBar);
+        } else {
+            alert('创建知识库失败: ' + result.message);
+            progressBar.style.display = 'none';
+        }
+    } catch (error) {
+        console.error('创建知识库出错:', error);
+        alert('创建知识库出错，请查看控制台日志');
+        progressBar.style.display = 'none';
+    }
+}
+
+// 添加文件到知识库
+async function addFileToKnowledgeBase(form) {
+    const knowledgeId = form.getAttribute('data-id');
+    const fileInput = form.querySelector('input[type="file"]');
+    const submitBtn = form.querySelector('button[type="submit"]');
+    
+    if (!fileInput.files[0]) {
+        alert('请选择文件');
+        return;
+    }
+    
+    // 禁用提交按钮
+    submitBtn.disabled = true;
+    submitBtn.textContent = '上传中...';
+    
+    const formData = new FormData();
+    formData.append('file', fileInput.files[0]);
+    
+    try {
+        const response = await fetch(`/api/knowledge/${knowledgeId}/documents`, {
+            method: 'POST',
+            body: formData
+        });
+        
+        const result = await response.json();
+        
+        if (result.success) {
+            alert('文件上传成功，开始处理');
+            // 轮询处理进度
+            pollProgressSimple(result.task_id, submitBtn);
+        } else {
+            alert('添加文件失败: ' + result.message);
+            submitBtn.disabled = false;
+            submitBtn.textContent = '添加文件';
+        }
+    } catch (error) {
+        console.error('添加文件出错:', error);
+        alert('添加文件出错，请查看控制台日志');
+        submitBtn.disabled = false;
+        submitBtn.textContent = '添加文件';
+    }
+}
+
+// 删除知识库
+async function deleteKnowledgeBase(knowledgeId) {
+    if (!confirm('确定要删除这个知识库吗？此操作不可恢复。')) {
+        return;
+    }
+    
+    try {
+        const response = await fetch(`/api/knowledge/${knowledgeId}`, {
+            method: 'DELETE'
+        });
+        
+        const result = await response.json();
+        
+        if (result.success) {
+            alert('知识库删除成功!');
+            loadKnowledgeBases(); // 重新加载知识库列表
+        } else {
+            alert('删除知识库失败: ' + result.message);
+        }
+    } catch (error) {
+        console.error('删除知识库出错:', error);
+        alert('删除知识库出错，请查看控制台日志');
+    }
+}
+
+// 轮询进度（带进度条显示）
+function pollProgress(taskId, progressElement) {
+    const progressBar = progressElement.querySelector('.progress-bar');
+    
+    const interval = setInterval(async () => {
+        try {
+            const response = await fetch(`/api/progress/${taskId}`);
+            const data = await response.json();
+            
+            if (data.success) {
+                const progressData = data.data;
+                
+                // 更新进度条
+                progressBar.style.width = progressData.progress + '%';
+                
+                // 处理完成或出错时
+                if (progressData.progress >= 100 || progressData.error) {
+                    clearInterval(interval);
+                    
+                    if (progressData.error) {
+                        alert('处理失败: ' + progressData.status);
+                    } else {
+                        alert(`知识库处理成功! 已处理${progressData.docCount}个文档片段`);
+                    }
+                    
+                    // 隐藏进度条
+                    progressElement.style.display = 'none';
+                    
+                    // 重置表单
+                    document.getElementById('knowledge-name').value = '';
+                    document.getElementById('knowledge-file').value = '';
+                    
+                    // 重新加载知识库列表
+                    loadKnowledgeBases();
+                }
+            }
+        } catch (error) {
+            console.error('获取进度信息出错:', error);
+        }
+    }, 1000); // 每秒轮询一次
+}
+
+// 简化版轮询进度（不显示进度条）
+function pollProgressSimple(taskId, buttonElement) {
+    const originalText = buttonElement.textContent;
+    
+    const interval = setInterval(async () => {
+        try {
+            const response = await fetch(`/api/progress/${taskId}`);
+            const data = await response.json();
+            
+            if (data.success) {
+                const progressData = data.data;
+                
+                // 处理完成或出错时
+                if (progressData.progress >= 100 || progressData.error) {
+                    clearInterval(interval);
+                    
+                    if (progressData.error) {
+                        alert('处理失败: ' + progressData.status);
+                    } else {
+                        alert(`处理成功! 已处理${progressData.docCount}个文档片段`);
+                    }
+                    
+                    // 恢复按钮
+                    buttonElement.disabled = false;
+                    buttonElement.textContent = originalText;
+                    
+                    // 重新加载知识库列表
+                    loadKnowledgeBases();
+                }
+            }
+        } catch (error) {
+            console.error('获取进度信息出错:', error);
+        }
+    }, 1000); // 每秒轮询一次
+}
+
+// 使用AI生成工作流
+async function generateAIWorkflow() {
+    const description = document.getElementById('agent-description').value;
+    const subject = document.getElementById('agent-subject').value || document.getElementById('agent-name').value;
+    
+    if (!description) {
+        alert('请先填写Agent描述，以便AI生成工作流');
+        nextTab('basic-tab');
+        return;
+    }
+    
+    // 显示加载状态
+    const workflowCanvas = document.getElementById('workflow-canvas');
+    workflowCanvas.innerHTML = `
+        <div class="text-center py-5">
+            <div class="spinner-border text-primary" role="status">
+                <span class="visually-hidden">生成中...</span>
+            </div>
+            <p class="mt-3">AI正在设计工作流，请稍候...</p>
+        </div>
+    `;
+    
+    try {
+        const response = await fetch('/api/agent/ai-assist', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                description: description,
+                subject: subject,
+                plugins: selectedPlugins,
+                knowledge_bases: selectedKnowledgeBases
+            })
+        });
+        
+        const result = await response.json();
+        
+        if (result.success) {
+            // 保存工作流
+            currentWorkflow = result.workflow;
+            
+            // 更新代码视图
+            updateWorkflowCodeView(currentWorkflow);
+            
+            // 处理AI推荐的知识库和插件
+            let recommendationHtml = '';
+            let recommendationsApplied = false;
+            
+            // 应用推荐的知识库
+            if (result.recommended_knowledge_bases && result.recommended_knowledge_bases.length > 0) {
+                // 更新选择的知识库
+                selectedKnowledgeBases = result.recommended_knowledge_bases;
+                
+                // 更新UI中的选择状态
+                document.querySelectorAll('#knowledge-list .plugin-option').forEach(item => {
+                    const kbId = item.getAttribute('data-id');
+                    const selected = selectedKnowledgeBases.includes(kbId);
+                    
+                    item.classList.toggle('selected', selected);
+                    const checkbox = item.querySelector('input[type="checkbox"]');
+                    if (checkbox) checkbox.checked = selected;
+                });
+                
+                recommendationsApplied = true;
+                recommendationHtml += `
+                    <div class="mb-3">
+                        <h6>AI推荐的知识库:</h6>
+                        <ul>
+                            ${selectedKnowledgeBases.map(kb => `<li>${kb}</li>`).join('')}
+                        </ul>
+                    </div>
+                `;
+            }
+            
+            // 应用推荐的插件
+            if (result.recommended_plugins && result.recommended_plugins.length > 0) {
+                // 更新选择的插件
+                selectedPlugins = result.recommended_plugins;
+                
+                // 更新UI中的选择状态
+                document.querySelectorAll('[data-plugin]').forEach(item => {
+                    const pluginId = item.getAttribute('data-plugin');
+                    const selected = selectedPlugins.includes(pluginId);
+                    
+                    item.classList.toggle('selected', selected);
+                    const checkbox = item.querySelector('input[type="checkbox"]');
+                    if (checkbox) checkbox.checked = selected;
+                });
+                
+                recommendationsApplied = true;
+                recommendationHtml += `
+                    <div class="mb-3">
+                        <h6>AI推荐的插件:</h6>
+                        <ul>
+                            ${selectedPlugins.map(plugin => {
+                                let pluginName = plugin;
+                                if (plugin === 'code') pluginName = '代码执行';
+                                if (plugin === 'visualization') pluginName = '3D可视化';
+                                if (plugin === 'mindmap') pluginName = '思维导图';
+                                return `<li>${pluginName}</li>`;
+                            }).join('')}
+                        </ul>
+                    </div>
+                `;
+            }
+            
+            // 显示推荐结果
+            if (recommendationsApplied) {
+                workflowCanvas.innerHTML = `
+                    <div class="alert alert-success mb-3">
+                        <i class="bi bi-check-circle-fill me-2"></i>
+                        AI已成功设计工作流并推荐了知识库和插件
+                    </div>
+                    ${recommendationHtml}
+                    <div id="workflow-visualization-container"></div>
+                `;
+            } else {
+                workflowCanvas.innerHTML = `
+                    <div class="alert alert-info mb-3">
+                        <i class="bi bi-info-circle-fill me-2"></i>
+                        AI已设计工作流但未推荐额外的知识库或插件
+                    </div>
+                    <div id="workflow-visualization-container"></div>
+                `;
+            }
+            
+            // 渲染工作流视图
+            setTimeout(() => {
+                renderWorkflowVisualization(currentWorkflow, 'workflow-canvas');
+            }, 200);
+            
+        } else {
+            workflowCanvas.innerHTML = `
+                <div class="alert alert-danger m-3">
+                    <i class="bi bi-exclamation-triangle-fill me-2"></i>
+                    生成工作流失败: ${result.message}
+                </div>
+            `;
+        }
+    } catch (error) {
+        console.error('生成工作流出错:', error);
+        workflowCanvas.innerHTML = `
+            <div class="alert alert-danger m-3">
+                <i class="bi bi-exclamation-triangle-fill me-2"></i>
+                生成工作流时发生错误，请重试
+            </div>
+        `;
+    }
+}
+
+// 更新工作流代码视图
+function updateWorkflowCodeView(workflow) {
+    const workflowCodeElement = document.getElementById('workflow-code');
+    if (workflowCodeElement) {
+        workflowCodeElement.textContent = JSON.stringify(workflow, null, 2);
+    }
+}
+
+// 创建Agent
+async function createAgent() {
+    const name = document.getElementById('agent-name').value;
+    const description = document.getElementById('agent-description').value;
+    const subject = document.getElementById('agent-subject').value || name; // 使用课程名称，如果未填写则使用Agent名称
+    const instructor = document.getElementById('agent-instructor').value || '教师'; // 使用指导教师，如果未填写则使用默认值
+    const type = document.getElementById('agent-type').value;
+    
+    if (!name) {
+        alert('请填写Agent名称');
+        nextTab('basic-tab');
+        return;
+    }
+    
+    // 准备Agent数据
+    const agentData = {
+        name: name,
+        description: description,
+        subject: subject,
+        instructor: instructor,
+        type: type,
+        plugins: selectedPlugins,
+        knowledge_bases: selectedKnowledgeBases,
+        workflow: currentWorkflow
+    };
+    
+    try {
+        const response = await fetch('/api/agent/create', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(agentData)
+        });
+        
+        const result = await response.json();
+        
+        if (result.success) {
+            alert(`Agent '${name}' 创建成功!`);
+            
+            // 重置表单
+            document.getElementById('agent-name').value = '';
+            document.getElementById('agent-description').value = '';
+            document.getElementById('agent-subject').value = '';
+            document.getElementById('agent-instructor').value = '';
+            document.getElementById('agent-type').value = 'educational';
+            selectedPlugins = [];
+            selectedKnowledgeBases = [];
+            currentWorkflow = { nodes: [], edges: [] };
+            
+            // 重置插件选择
+            document.querySelectorAll('.plugin-option').forEach(item => {
+                item.classList.remove('selected');
+                item.querySelector('input[type="checkbox"]').checked = false;
+            });
+            
+            // 重置工作流视图
+            document.getElementById('workflow-canvas').innerHTML = `
+                <div class="p-4 text-center text-muted">
+                    点击"使用AI自动设计工作流"按钮，或手动设计工作流
+                </div>
+            `;
+            
+            // 更新代码视图
+            updateWorkflowCodeView(currentWorkflow);
+            
+            // 切换到Agent列表页面
+            switchSection('agent-list');
+            
+            // 重新加载Agent列表
+            loadAgents();
+        } else {
+            alert('创建Agent失败: ' + result.message);
+        }
+    } catch (error) {
+        console.error('创建Agent出错:', error);
+        alert('创建Agent出错，请查看控制台日志');
+    }
+}
+
+// 加载Agent列表
+async function loadAgents() {
+    try {
+        const response = await fetch('/api/agent/list');
+        const result = await response.json();
+        
+        if (result.success) {
+            allAgents = result.agents || [];
+            
+            // 更新仪表盘计数
+            document.getElementById('agent-count').textContent = allAgents.length;
+            
+            // 计算分发链接总数
+            let distributionCount = 0;
+            allAgents.forEach(agent => {
+                distributionCount += agent.distribution_count || 0;
+            });
+            document.getElementById('distribution-count').textContent = distributionCount;
+            
+            // 更新最近创建的Agent
+            updateRecentAgents();
+            
+            // 更新Agent列表页面
+            updateAgentListPage();
+        } else {
+            console.error('加载Agent列表失败:', result.message);
+        }
+    } catch (error) {
+        console.error('加载Agent列表出错:', error);
+    }
+}
+
+// 更新最近创建的Agent列表
+function updateRecentAgents() {
+    const recentAgentsElement = document.getElementById('recent-agents');
+    
+    if (recentAgentsElement) {
+        if (allAgents.length === 0) {
+            recentAgentsElement.innerHTML = `
+                <div class="alert alert-info">
+                    <i class="bi bi-info-circle me-2"></i>
+                    您还没有创建Agent
+                </div>
+                <div class="text-center">
+                    <button class="btn btn-primary" onclick="switchSection('create-agent')">
+                        创建第一个Agent
+                    </button>
+                </div>
+            `;
+        } else {
+            // 只显示最近3个Agent
+            const recentAgents = allAgents.slice(0, 3);
+            
+            recentAgentsElement.innerHTML = '';
+            
+            recentAgents.forEach(agent => {
+                const item = document.createElement('div');
+                item.className = 'agent-item';
+                
+                const createdDate = new Date(agent.created_at * 1000);
+                const formattedDate = createdDate.toLocaleDateString();
+                
+                // 添加学科和指导教师信息
+                const subjectInfo = agent.subject ? `<small class="text-muted me-3"><i class="bi bi-book me-1"></i>${agent.subject}</small>` : '';
+                const instructorInfo = agent.instructor ? `<small class="text-muted"><i class="bi bi-person me-1"></i>${agent.instructor}</small>` : '';
+                
+                item.innerHTML = `
+                    <div class="header">
+                        <h5 class="title">${agent.name}</h5>
+                        <span class="badge badge-primary">${agent.type || 'educational'}</span>
+                    </div>
+                    <div class="description">${agent.description || '暂无描述'}</div>
+                    <div class="mt-2">
+                        ${subjectInfo}
+                        ${instructorInfo}
+                    </div>
+                    <div class="meta">
+                        <div>
+                            <i class="bi bi-calendar3"></i>
+                            ${formattedDate}
+                        </div>
+                        <div>
+                            <i class="bi bi-share"></i>
+                            ${agent.distribution_count || 0}个分发
+                            </div>
+                   </div>
+               `;
+               
+               recentAgentsElement.appendChild(item);
+           });
+       }
+   }
+}
+
+// 更新Agent列表页面
+function updateAgentListPage() {
+   const agentListContainer = document.getElementById('agent-list-container');
+   
+   if (agentListContainer) {
+       if (allAgents.length === 0) {
+           agentListContainer.innerHTML = `
+               <div class="alert alert-info">
+                   <i class="bi bi-info-circle me-2"></i>
+                   您还没有创建Agent
+               </div>
+               <div class="text-center">
+                   <button class="btn btn-primary" onclick="switchSection('create-agent')">
+                       创建第一个Agent
+                   </button>
+               </div>
+           `;
+       } else {
+           agentListContainer.innerHTML = '';
+           
+           allAgents.forEach(agent => {
+               const item = document.createElement('div');
+               item.className = 'agent-item';
+               
+               const createdDate = new Date(agent.created_at * 1000);
+               const formattedDate = createdDate.toLocaleDateString();
+               
+               // 构建插件和知识库标签
+               let pluginsHtml = '';
+               if (agent.plugins && agent.plugins.length > 0) {
+                   pluginsHtml = '<div class="mt-2"><small class="text-muted me-2">插件:</small>';
+                   agent.plugins.forEach(plugin => {
+                       let pluginName = '未知';
+                       let pluginIcon = 'puzzle';
+                       
+                       if (plugin === 'code') {
+                           pluginName = '代码执行';
+                           pluginIcon = 'code-square';
+                       } else if (plugin === 'visualization') {
+                           pluginName = '3D可视化';
+                           pluginIcon = 'bar-chart';
+                       } else if (plugin === 'mindmap') {
+                           pluginName = '思维导图';
+                           pluginIcon = 'diagram-3';
+                       }
+                       
+                       pluginsHtml += `
+                           <span class="badge bg-light text-dark me-1">
+                               <i class="bi bi-${pluginIcon} me-1"></i>
+                               ${pluginName}
+                           </span>
+                       `;
+                   });
+                   pluginsHtml += '</div>';
+                 }
+                 
+                 let knowledgeHtml = '';
+                 if (agent.knowledge_bases && agent.knowledge_bases.length > 0) {
+                     knowledgeHtml = '<div class="mt-2"><small class="text-muted me-2">知识库:</small>';
+                     agent.knowledge_bases.forEach(kb => {
+                         // 查找知识库名称
+                         const knowledge = allKnowledgeBases.find(k => k.id === kb);
+                         const knowledgeName = knowledge ? knowledge.name : kb;
+                         
+                         knowledgeHtml += `
+                             <span class="badge bg-light text-dark me-1">
+                                 <i class="bi bi-journal-text me-1"></i>
+                                 ${knowledgeName}
+                             </span>
+                         `;
+                     });
+                     knowledgeHtml += '</div>';
+                 }
+                 
+                 // 添加学科和指导教师信息
+                 const subjectInfo = agent.subject ? `<small class="text-muted me-3"><i class="bi bi-book me-1"></i>${agent.subject}</small>` : '';
+                 const instructorInfo = agent.instructor ? `<small class="text-muted"><i class="bi bi-person me-1"></i>${agent.instructor}</small>` : '';
+                 
+                 item.innerHTML = `
+                     <div class="header">
+                         <h5 class="title">${agent.name}</h5>
+                         <div>
+                             <button class="btn btn-sm btn-primary me-1" onclick="showCreateDistributionModal('${agent.id}')">
+                                 <i class="bi bi-share"></i> 分发
+                             </button>
+                             <button class="btn btn-sm btn-outline-secondary me-1" onclick="showAgentDetail('${agent.id}')">
+                                 <i class="bi bi-info-circle"></i> 详情
+                             </button>
+                             <button class="btn btn-sm btn-outline-danger" onclick="deleteAgent('${agent.id}')">
+                                 <i class="bi bi-trash"></i>
+                             </button>
+                         </div>
+                     </div>
+                     <div class="description">${agent.description || '暂无描述'}</div>
+                     <div class="mt-2">
+                         ${subjectInfo}
+                         ${instructorInfo}
+                     </div>
+                     ${pluginsHtml}
+                     ${knowledgeHtml}
+                     <div class="meta">
+                         <div>
+                             <i class="bi bi-calendar3"></i>
+                             ${formattedDate}
+                         </div>
+                         <div>
+                             <i class="bi bi-share"></i>
+                             ${agent.distribution_count || 0}个分发
+                         </div>
+                         <div>
+                             <i class="bi bi-eye"></i>
+                             ${agent.usage_count || 0}次使用
+                         </div>
+                     </div>
+                 `;
+                 
+                 agentListContainer.appendChild(item);
+             });
+         }
+     }
+ }
+ 
+ // 显示Agent详情
+ async function showAgentDetail(agentId) {
+     try {
+         // 获取Agent详细信息
+         const response = await fetch(`/api/agent/${agentId}`);
+         const result = await response.json();
+         
+         if (result.success) {
+             const agent = result.agent;
+             
+             // 更新模态框内容
+             const modalTitle = document.getElementById('agent-detail-title');
+             const modalBody = document.getElementById('agent-detail-body');
+             
+             modalTitle.textContent = agent.name;
+             
+             // 格式化创建时间
+             const createdDate = new Date(agent.created_at * 1000);
+             const formattedDate = createdDate.toLocaleString();
+             
+             // 构建模态框内容
+             modalBody.innerHTML = `
+                 <div class="mb-3">
+                     <h6>描述</h6>
+                     <p>${agent.description || '暂无描述'}</p>
+                 </div>
+                 
+                 <div class="row mb-3">
+                     <div class="col-md-6">
+                         <h6>学科/课程</h6>
+                         <p>${agent.subject || agent.name}</p>
+                     </div>
+                     <div class="col-md-6">
+                         <h6>指导教师</h6>
+                         <p>${agent.instructor || '教师'}</p>
+                     </div>
+                 </div>
+                 
+                 <div class="row mb-3">
+                     <div class="col-md-6">
+                         <h6>创建时间</h6>
+                         <p>${formattedDate}</p>
+                     </div>
+                     <div class="col-md-6">
+                         <h6>使用次数</h6>
+                         <p>${agent.stats ? agent.stats.usage_count || 0 : 0}次</p>
+                     </div>
+                 </div>
+                 
+                 <div class="mb-3">
+                     <h6>插件</h6>
+                     ${getPluginsHtml(agent.plugins)}
+                 </div>
+                 
+                 <div class="mb-3">
+                     <h6>知识库</h6>
+                     ${getKnowledgeBasesHtml(agent.knowledge_bases)}
+                 </div>
+                 
+                 <div class="mb-3">
+                     <h6>分发链接</h6>
+                     ${getDistributionsHtml(agent.distributions, agent.id)}
+                 </div>
+                 
+                 <div class="mb-4">
+                     <h6>工作流配置</h6>
+                     <ul class="nav nav-tabs mb-3" id="detailWorkflowTabs" role="tablist">
+                         <li class="nav-item" role="presentation">
+                             <button class="nav-link active" id="detail-visual-tab" data-bs-toggle="tab" data-bs-target="#detail-visual-view" type="button" role="tab">可视化视图</button>
+                         </li>
+                         <li class="nav-item" role="presentation">
+                             <button class="nav-link" id="detail-code-tab" data-bs-toggle="tab" data-bs-target="#detail-code-view" type="button" role="tab">代码视图</button>
+                         </li>
+                     </ul>
+                     <div class="tab-content" id="detailWorkflowContent">
+                         <div class="tab-pane fade show active" id="detail-visual-view" role="tabpanel">
+                             <div id="detail-workflow-canvas" class="workflow-canvas"></div>
+                         </div>
+                         <div class="tab-pane fade" id="detail-code-view" role="tabpanel">
+                             <div class="p-3 bg-light border rounded">
+                                 <pre class="mb-0">${JSON.stringify(agent.workflow, null, 2)}</pre>
+                             </div>
+                         </div>
+                     </div>
+                 </div>
+             `;
+             
+             // 存储工作流数据
+             modalBody.dataset.agentWorkflow = JSON.stringify(agent.workflow);
+             
+             // 显示模态框
+             const modal = new bootstrap.Modal(document.getElementById('agentDetailModal'));
+             modal.show();
+             
+             // 在模态框显示后初始化工作流标签事件
+             document.getElementById('agentDetailModal').addEventListener('shown.bs.modal', function() {
+                 // 初始化详情模态框内的标签切换
+                 document.querySelectorAll('#detailWorkflowTabs .nav-link').forEach(tab => {
+                     tab.addEventListener('click', function(event) {
+                         event.preventDefault();
+                         
+                         const targetId = this.getAttribute('data-bs-target');
+                         const targetPane = document.querySelector(targetId);
+                         
+                         // 切换标签激活状态
+                         document.querySelectorAll('#detailWorkflowTabs .nav-link').forEach(t => 
+                             t.classList.remove('active'));
+                         this.classList.add('active');
+                         
+                         // 切换内容区域显示状态
+                         document.querySelectorAll('#detailWorkflowContent .tab-pane').forEach(p => 
+                             p.classList.remove('show', 'active'));
+                         targetPane.classList.add('show', 'active');
+                         
+                         // 如果切换到可视化视图，重新渲染工作流
+                         if (targetId === '#detail-visual-view') {
+                             setTimeout(() => {
+                                 const workflow = JSON.parse(modalBody.dataset.agentWorkflow);
+                                 renderWorkflowVisualization(workflow, 'detail-workflow-canvas');
+                             }, 200);
+                         }
+                     });
+                 });
+                 
+                 // 立即渲染工作流可视化
+                 setTimeout(() => {
+                     const workflow = JSON.parse(modalBody.dataset.agentWorkflow);
+                     renderWorkflowVisualization(workflow, 'detail-workflow-canvas');
+                 }, 200);
+             });
+         } else {
+             alert('获取Agent详情失败: ' + result.message);
+         }
+     } catch (error) {
+         console.error('获取Agent详情出错:', error);
+         alert('获取Agent详情出错，请查看控制台日志');
+     }
+ }
+ 
+ // 辅助函数，用于生成插件HTML
+ function getPluginsHtml(plugins) {
+     if (!plugins || plugins.length === 0) {
+         return '<p>无</p>';
+     }
+     
+     let html = '<ul>';
+     plugins.forEach(plugin => {
+         let pluginName = '未知';
+         
+         if (plugin === 'code') {
+             pluginName = '代码执行';
+         } else if (plugin === 'visualization') {
+             pluginName = '3D可视化';
+         } else if (plugin === 'mindmap') {
+             pluginName = '思维导图';
+         }
+         
+         html += `<li>${pluginName}</li>`;
+     });
+     html += '</ul>';
+     
+     return html;
+ }
+ 
+ // 辅助函数，用于生成知识库HTML
+ function getKnowledgeBasesHtml(knowledgeBases) {
+     if (!knowledgeBases || knowledgeBases.length === 0) {
+         return '<p>无</p>';
+     }
+     
+     let html = '<ul>';
+     knowledgeBases.forEach(kb => {
+         // 查找知识库名称
+         const knowledge = allKnowledgeBases.find(k => k.id === kb);
+         const knowledgeName = knowledge ? knowledge.name : kb;
+         
+         html += `<li>${knowledgeName}</li>`;
+     });
+     html += '</ul>';
+     
+     return html;
+ }
+ 
+ // 辅助函数，用于生成分发链接HTML
+ function getDistributionsHtml(distributions, agentId) {
+     if (!distributions || distributions.length === 0) {
+         return '<p>无</p>';
+     }
+     
+     let html = '<div class="list-group">';
+     distributions.forEach(dist => {
+         const expiryText = dist.expires_at > 0 
+             ? `过期时间: ${new Date(dist.expires_at * 1000).toLocaleString()}`
+             : '永不过期';
+             
+         const url = `/student/${agentId}?token=${dist.token}`;
+         
+         html += `
+             <div class="distribution-link">
+                 <div>
+                     <div class="mb-1">${url}</div>
+                     <small class="text-muted">${expiryText} | 使用次数: ${dist.usage_count || 0}</small>
+                 </div>
+                 <button class="btn btn-sm btn-outline-primary" onclick="copyToClipboard('${url}')">
+                     <i class="bi bi-clipboard"></i> 复制
+                 </button>
+             </div>
+         `;
+     });
+     html += '</div>';
+     
+     return html;
+ }
+ 
+ // 删除Agent
+ async function deleteAgent(agentId) {
+     if (!confirm('确定要删除这个Agent吗？此操作不可恢复。')) {
+         return;
+     }
+     
+     try {
+         const response = await fetch(`/api/agent/${agentId}`, {
+             method: 'DELETE'
+         });
+         
+         const result = await response.json();
+         
+         if (result.success) {
+             alert('Agent删除成功!');
+             loadAgents(); // 重新加载Agent列表
+         } else {
+             alert('删除Agent失败: ' + result.message);
+         }
+     } catch (error) {
+         console.error('删除Agent出错:', error);
+         alert('删除Agent出错，请查看控制台日志');
+     }
+ }
+ 
+ // 显示创建分发链接模态框
+ function showCreateDistributionModal(agentId) {
+     document.getElementById('distribution-agent-id').value = agentId;
+     
+     // 显示模态框
+     const modal = new bootstrap.Modal(document.getElementById('createDistributionModal'));
+     modal.show();
+ }
+ 
+ // 创建分发链接
+ async function createDistribution() {
+     const agentId = document.getElementById('distribution-agent-id').value;
+     const expiresIn = parseInt(document.getElementById('distribution-expires').value);
+     
+     if (!agentId) {
+         alert('Agent ID不能为空');
+         return;
+     }
+     
+     try {
+         const response = await fetch(`/api/agent/${agentId}/distribute`, {
+             method: 'POST',
+             headers: { 'Content-Type': 'application/json' },
+             body: JSON.stringify({ expires_in: expiresIn })
+         });
+         
+         const result = await response.json();
+         
+         if (result.success) {
+             // 隐藏创建模态框
+             const createModal = bootstrap.Modal.getInstance(document.getElementById('createDistributionModal'));
+             createModal.hide();
+             
+             // 更新分发链接输入框
+             const fullUrl = window.location.origin + result.distribution.link;
+             document.getElementById('distribution-link').value = fullUrl;
+             
+             // 显示分发链接模态框
+             const showModal = new bootstrap.Modal(document.getElementById('showDistributionModal'));
+             showModal.show();
+             
+             // 重新加载Agent列表
+             loadAgents();
+         } else {
+             alert('创建分发链接失败: ' + result.message);
+         }
+     } catch (error) {
+         console.error('创建分发链接出错:', error);
+         alert('创建分发链接出错，请查看控制台日志');
+     }
+ }
+ 
+ // 复制到剪贴板
+ function copyToClipboard(textOrElementId) {
+     let text;
+     
+     if (textOrElementId.startsWith('/') || textOrElementId.startsWith('http')) {
+         // 直接传入的文本
+         text = textOrElementId;
+     } else {
+         // 传入的是元素ID
+         const element = document.getElementById(textOrElementId);
+         text = element.value || element.textContent;
+     }
+     
+     navigator.clipboard.writeText(text).then(() => {
+         alert('已复制到剪贴板!');
+     }).catch(err => {
+         console.error('复制失败:', err);
+     });
+ }
+ 
+ // 根据节点类型获取图标
+ function getNodeIcon(type) {
+     switch (type) {
+         case 'intent_recognition':
+             return 'AI';
+         case 'knowledge_query':
+             return 'KB';
+         case 'plugin_call':
+             return 'API';
+         case 'generate_response':
+             return 'AI';
+         default:
+             return '';
+     }
+ }
+ 
+ // 渲染工作流可视化
+ function renderWorkflowVisualization(workflow, containerId) {
+     const container = document.getElementById(containerId);
+     if (!container) return;
+     
+     // 清空容器
+     container.innerHTML = '';
+     
+     // 如果没有工作流数据，显示提示
+     if (!workflow || !workflow.nodes || workflow.nodes.length === 0) {
+         container.innerHTML = `
+             <div class="p-4 text-center text-muted">
+                 暂无工作流数据
+             </div>
+         `;
+         return;
+     }
+     
+     // 创建或重置jsPlumb实例
+     if (jsPlumbWorkflowInstance) {
+         jsPlumbWorkflowInstance.reset();
+     }
+     
+     jsPlumbWorkflowInstance = jsPlumb.getInstance({
+         Endpoint: ["Dot", { radius: 4 }],
+         Connector: ["Bezier", { curviness: 50 }],
+         PaintStyle: { stroke: "#4361ee", strokeWidth: 2 },
+         HoverPaintStyle: { stroke: "#3a56e4", strokeWidth: 3 },
+         ConnectionOverlays: [
+             ["Arrow", { location: 1, width: 10, length: 10, foldback: 0.7 }]
+         ],
+         Container: containerId
+     });
+     
+     // 创建节点
+     workflow.nodes.forEach(node => {
+         const nodeEl = document.createElement('div');
+         nodeEl.id = node.id;
+         nodeEl.className = `workflow-node node-type-${node.type}`;
+         nodeEl.innerHTML = `
+             <div class="node-icon">${getNodeIcon(node.type)}</div>
+             <div class="node-content">${node.data.name}</div>
+         `;
+         
+         container.appendChild(nodeEl);
+     });
+     
+     // 计算节点依赖关系
+     const dependencies = {};
+     const dependents = {};
+     
+     workflow.nodes.forEach(node => {
+         dependencies[node.id] = [];
+         dependents[node.id] = [];
+     });
+     
+     workflow.edges.forEach(edge => {
+         dependencies[edge.target].push(edge.source);
+         dependents[edge.source].push(edge.target);
+     });
+     
+     // 计算层级
+     const nodeLevels = {};
+     const queue = [];
+     
+     // 找到没有依赖的节点（入度为0的节点）
+     workflow.nodes.forEach(node => {
+         if (dependencies[node.id].length === 0) {
+             nodeLevels[node.id] = 0;
+             queue.push(node.id);
+         }
+     });
+     
+     // BFS计算层级
+     while (queue.length > 0) {
+         const currentId = queue.shift();
+         const currentLevel = nodeLevels[currentId];
+         
+         dependents[currentId].forEach(dependentId => {
+             const allDependenciesProcessed = dependencies[dependentId].every(
+                 depId => nodeLevels[depId] !== undefined
+             );
+             
+             if (allDependenciesProcessed) {
+                 const maxDependencyLevel = Math.max(
+                     ...dependencies[dependentId].map(depId => nodeLevels[depId])
+                 );
+                 nodeLevels[dependentId] = maxDependencyLevel + 1;
+                 queue.push(dependentId);
+             }
+         });
+     }
+     
+     // 按层级对节点进行布局
+     const levelGroups = {};
+     Object.keys(nodeLevels).forEach(nodeId => {
+         const level = nodeLevels[nodeId];
+         if (!levelGroups[level]) {
+             levelGroups[level] = [];
+         }
+         levelGroups[level].push(nodeId);
+     });
+     
+     const containerWidth = container.clientWidth;
+     const containerHeight = container.clientHeight;
+     const levelCount = Object.keys(levelGroups).length;
+     const levelHeight = containerHeight / (levelCount > 1 ? levelCount : 2);
+     
+     Object.entries(levelGroups).forEach(([level, nodeIds]) => {
+         const levelIndex = parseInt(level);
+         const nodeCount = nodeIds.length;
+         const nodeWidth = containerWidth / (nodeCount + 1);
+         
+         nodeIds.forEach((nodeId, index) => {
+             const node = document.getElementById(nodeId);
+             if (node) {
+                 node.style.top = `${levelIndex * levelHeight + 50}px`;
+                 node.style.left = `${(index + 1) * nodeWidth - (node.clientWidth / 2)}px`;
+             }
+         });
+     });
+     
+     // 为每个节点创建可拖动功能
+     workflow.nodes.forEach(node => {
+         const nodeEl = document.getElementById(node.id);
+         if (nodeEl) {
+             jsPlumbWorkflowInstance.draggable(nodeEl, {
+                 containment: container
+             });
+         }
+     });
+     
+     // 添加连接
+     setTimeout(() => {
+         workflow.edges.forEach(edge => {
+             const sourceEl = document.getElementById(edge.source);
+             const targetEl = document.getElementById(edge.target);
+             
+             if (sourceEl && targetEl) {
+                 const connection = jsPlumbWorkflowInstance.connect({
+                     source: sourceEl,
+                     target: targetEl,
+                     anchors: ["Bottom", "Top"],
+                     connector: ["Bezier", { curviness: 50 }],
+                     paintStyle: { stroke: "#4361ee", strokeWidth: 2 },
+                     endpoint: "Blank",
+                     overlays: [
+                         ["Arrow", { location: 1, width: 10, length: 10, foldback: 0.7 }]
+                     ]
+                 });
+                 
+                 // 添加连接标签
+                 if (edge.condition) {
+                     connection.addOverlay([
+                         "Label", {
+                             label: edge.condition,
+                             cssClass: "connection-label",
+                             location: 0.5
+                         }
+                     ]);
+                 }
+             }
+         });
+         
+         // 刷新所有连接
+         jsPlumbWorkflowInstance.repaintEverything();
+     }, 100);
+ }
+</script>
+</body>
+</html>

templates/student.html

@@ -0,0 +1,909 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AI学习助手</title>
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css">
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/[email protected]/font/bootstrap-icons.css">
+    <style>
+        :root {
+            --primary-color: #4361ee;
+            --secondary-color: #3f37c9;
+            --accent-color: #4cc9f0;
+            --success-color: #4caf50;
+            --warning-color: #ff9800;
+            --danger-color: #f44336;
+            --light-color: #f8f9fa;
+            --dark-color: #212529;
+            --border-color: #dee2e6;
+            --border-radius: 0.375rem;
+        }
+        
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            margin: 0;
+            padding: 0;
+            height: 100vh;
+            background-color: #f5f7fa;
+            color: #333;
+            display: flex;
+            flex-direction: column;
+        }
+        
+        .header {
+            background-color: #fff;
+            border-bottom: 1px solid var(--border-color);
+            padding: 1rem;
+            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+        }
+        
+        .header-content {
+            max-width: 1600px;
+            margin: 0 auto;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        
+        .header h1 {
+            margin: 0;
+            font-size: 1.5rem;
+            color: var(--primary-color);
+        }
+        
+        .main-container {
+            flex: 1;
+            display: flex;
+            max-width: 1600px;
+            margin: 0 auto;
+            padding: 1rem;
+            width: 100%;
+            box-sizing: border-box;
+            height: calc(100vh - 70px); /* Header height + padding */
+            overflow: hidden;
+        }
+        
+        .chat-container {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+            background-color: #fff;
+            border-radius: var(--border-radius);
+            box-shadow: 0 2px 5px rgba(0, 0, 0, 0.05);
+            border: 1px solid var(--border-color);
+            overflow: hidden;
+            height: 100%;
+            max-width: 800px;
+            margin: 0 auto;
+        }
+        
+        /* When plugins are active, adjust the chat container */
+        .main-container.with-plugin .chat-container {
+            margin: 0;
+            max-width: 350px;
+        }
+        
+        .chat-messages {
+            flex: 1;
+            overflow-y: auto;
+            padding: 1rem;
+            display: flex;
+            flex-direction: column;
+        }
+        
+        .message {
+            max-width: 90%;
+            margin-bottom: 1rem;
+            padding: 0.75rem 1rem;
+            border-radius: var(--border-radius);
+            position: relative;
+        }
+        
+        .user-message {
+            background-color: #e3f2fd;
+            align-self: flex-end;
+            color: #0d47a1;
+        }
+        
+        .bot-message {
+            background-color: #f5f5f5;
+            align-self: flex-start;
+            color: #333;
+            border-left: 3px solid var(--primary-color);
+        }
+        
+        .input-container {
+            padding: 1rem;
+            border-top: 1px solid var(--border-color);
+            background-color: #f9f9f9;
+        }
+        
+        .input-row {
+            display: flex;
+            gap: 0.5rem;
+        }
+        
+        .input-field {
+            flex: 1;
+            padding: 0.75rem 1rem;
+            border: 1px solid var(--border-color);
+            border-radius: var(--border-radius);
+            resize: none;
+            font-size: 0.95rem;
+        }
+        
+        .input-field:focus {
+            outline: none;
+            border-color: var(--primary-color);
+            box-shadow: 0 0 0 2px rgba(67, 97, 238, 0.1);
+        }
+        
+        .send-button {
+            padding: 0.75rem 1.5rem;
+            background-color: var(--primary-color);
+            color: white;
+            border: none;
+            border-radius: var(--border-radius);
+            cursor: pointer;
+            font-weight: 500;
+            transition: background-color 0.2s;
+        }
+        
+        .send-button:hover {
+            background-color: var(--secondary-color);
+        }
+        
+        .send-button:disabled {
+            background-color: #ccc;
+            cursor: not-allowed;
+        }
+        
+        .plugin-container {
+            display: none;
+            flex-direction: column;
+            background-color: #fff;
+            border-radius: var(--border-radius);
+            box-shadow: 0 2px 5px rgba(0, 0, 0, 0.05);
+            border: 1px solid var(--border-color);
+            overflow: hidden;
+            height: 100%;
+            flex: 2;
+            margin-left: 1rem;
+        }
+        
+        .plugin-header {
+            padding: 0.75rem 1rem;
+            border-bottom: 1px solid var(--border-color);
+            background-color: #f9f9f9;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        
+        .plugin-title {
+            margin: 0;
+            font-size: 1rem;
+            font-weight: 500;
+        }
+        
+        .plugin-close {
+            background: none;
+            border: none;
+            cursor: pointer;
+            font-size: 1rem;
+            color: #777;
+        }
+        
+        .plugin-content {
+            flex: 1;
+            overflow-y: auto;
+        }
+        
+        /* 代码执行插件样式 */
+        .code-plugin .plugin-content {
+            padding: 0;
+        }
+        
+        /* 可视化插件样式 */
+        .visualization-plugin .visualization-form {
+            margin-bottom: 1rem;
+            padding: 1rem;
+        }
+        
+        .visualization-plugin .visualization-result {
+            margin-top: 1rem;
+            text-align: center;
+            padding: 0 1rem;
+        }
+        
+        .visualization-plugin .visualization-image {
+            max-width: 100%;
+            border-radius: var(--border-radius);
+            box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
+        }
+        
+        /* 思维导图插件样式 */
+        .mindmap-plugin .mindmap-form {
+            margin-bottom: 1rem;
+            padding: 1rem;
+        }
+        
+        .mindmap-plugin .mindmap-result {
+            margin-top: 1rem;
+            text-align: center;
+            padding: 0 1rem;
+        }
+        
+        .mindmap-plugin .mindmap-image {
+            max-width: 100%;
+            border-radius: var(--border-radius);
+            box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
+        }
+        
+        /* 参考资料样式 */
+        .reference-container {
+            margin-top: 10px;
+            border-top: 1px dashed #ddd;
+            padding-top: 10px;
+        }
+        
+        .reference-toggle {
+            color: #666;
+            font-size: 0.9rem;
+            cursor: pointer;
+            display: flex;
+            align-items: center;
+        }
+        
+        .reference-content {
+            display: none;
+            margin-top: 10px;
+            padding: 10px;
+            background-color: #f9f9f9;
+            border-radius: 5px;
+            font-size: 0.85rem;
+        }
+        
+        /* 代码样式 */
+        pre {
+            background-color: #f8f9fa;
+            border-radius: 5px;
+            padding: 12px;
+            margin: 10px 0;
+            overflow-x: auto;
+            border: 1px solid #eee;
+        }
+        
+        code {
+            font-family: 'JetBrains Mono', 'Fira Code', Consolas, monospace;
+            font-size: 14px;
+        }
+        
+        /* 响应式样式 */
+        @media (max-width: 1200px) {
+            .main-container.with-plugin .chat-container {
+                max-width: 300px;
+            }
+        }
+        
+        @media (max-width: 992px) {
+            .main-container {
+                flex-direction: column;
+            }
+            
+            .main-container.with-plugin .chat-container {
+                max-width: 100%;
+                margin-bottom: 1rem;
+                height: 40vh;
+            }
+            
+            .plugin-container {
+                margin-left: 0;
+                height: calc(60vh - 32px);
+            }
+        }
+        
+        @media (max-width: 768px) {
+            .main-container {
+                padding: 0.5rem;
+            }
+        }
+    </style>
+</head>
+<body>
+    <header class="header">
+        <div class="header-content">
+            <h1>{{ agent_name }}</h1>
+            <div>
+                <span class="badge bg-primary">AI学习助手</span>
+            </div>
+        </div>
+    </header>
+    
+    <div class="main-container" id="main-container">
+        <div class="chat-container">
+            <div class="chat-messages" id="chat-messages">
+                <div class="message bot-message">
+                    <p>你好！我是{{ agent_name }}，有什么可以帮助你的吗？</p>
+                    {% if agent_description %}
+                    <p>{{ agent_description }}</p>
+                    {% endif %}
+                </div>
+            </div>
+            
+            <div class="input-container">
+                <div class="input-row">
+                    <textarea class="input-field" id="user-input" placeholder="输入您的问题..." rows="2"></textarea>
+                    <button class="send-button" id="send-button">
+                        <i class="bi bi-send"></i>
+                    </button>
+                </div>
+            </div>
+        </div>
+        
+        <!-- 代码执行插件 -->
+        <div class="plugin-container code-plugin" id="code-plugin">
+            <div class="plugin-header">
+                <h3 class="plugin-title">Python代码执行</h3>
+                <button class="plugin-close" id="close-code-plugin">
+                    <i class="bi bi-x-lg"></i>
+                </button>
+            </div>
+            <div class="plugin-content">
+                <iframe id="code-execution-frame" src="" style="width: 100%; height: 100%; border: none;"></iframe>
+            </div>
+        </div>
+        
+        <!-- 3D可视化插件 -->
+        <div class="plugin-container visualization-plugin" id="visualization-plugin">
+            <div class="plugin-header">
+                <h3 class="plugin-title">3D可视化</h3>
+                <button class="plugin-close" id="close-visualization-plugin">
+                    <i class="bi bi-x-lg"></i>
+                </button>
+            </div>
+            <div class="plugin-content">
+                <div class="visualization-result" id="visualization-result">
+                    <div class="text-center py-4">
+                        <div class="spinner-border text-primary" role="status">
+                            <span class="visually-hidden">加载中...</span>
+                        </div>
+                        <p class="mt-3">正在准备3D可视化...</p>
+                    </div>
+                </div>
+            </div>
+        </div>
+        
+        <!-- 思维导图插件 -->
+        <div class="plugin-container mindmap-plugin" id="mindmap-plugin">
+            <div class="plugin-header">
+                <h3 class="plugin-title">思维导图</h3>
+                <button class="plugin-close" id="close-mindmap-plugin">
+                    <i class="bi bi-x-lg"></i>
+                </button>
+            </div>
+            <div class="plugin-content">
+                <div class="mindmap-result" id="mindmap-result">
+                    <div class="text-center py-4">
+                        <div class="spinner-border text-primary" role="status">
+                            <span class="visually-hidden">加载中...</span>
+                        </div>
+                        <p class="mt-3">正在生成思维导图...</p>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+    
+    <script>
+        // 全局变量
+        const agentId = "{{ agent_id }}";
+        const token = "{{ token }}";
+        let executionContext = null;
+        const mainContainer = document.getElementById('main-container');
+        
+        // DOM元素
+        const chatMessages = document.getElementById('chat-messages');
+        const userInput = document.getElementById('user-input');
+        const sendButton = document.getElementById('send-button');
+        
+        // 代码执行插件元素
+        const codePlugin = document.getElementById('code-plugin');
+        const closeCodePlugin = document.getElementById('close-code-plugin');
+        const codeExecutionFrame = document.getElementById('code-execution-frame');
+        
+        // 3D可视化插件元素
+        const visualizationPlugin = document.getElementById('visualization-plugin');
+        const closeVisualizationPlugin = document.getElementById('close-visualization-plugin');
+        const visualizationResult = document.getElementById('visualization-result');
+        
+        // 思维导图插件元素
+        const mindmapPlugin = document.getElementById('mindmap-plugin');
+        const closeMindmapPlugin = document.getElementById('close-mindmap-plugin');
+        const mindmapResult = document.getElementById('mindmap-result');
+        
+        // 页面加载完成后执行
+        document.addEventListener('DOMContentLoaded', function() {
+            // 初始化发送按钮事件
+            sendButton.addEventListener('click', sendMessage);
+            
+            // 初始化输入框回车事件
+            userInput.addEventListener('keypress', function(e) {
+                if (e.key === 'Enter' && !e.shiftKey) {
+                    e.preventDefault();
+                    sendMessage();
+                }
+            });
+            
+            // 初始化插件关闭事件
+            closeCodePlugin.addEventListener('click', () => {
+                codePlugin.style.display = 'none';
+                // 清空iframe源以停止任何运行中的代码
+                codeExecutionFrame.src = '';
+                updateMainContainerLayout();
+            });
+            
+            closeVisualizationPlugin.addEventListener('click', () => {
+                visualizationPlugin.style.display = 'none';
+                updateMainContainerLayout();
+            });
+            
+            closeMindmapPlugin.addEventListener('click', () => {
+                mindmapPlugin.style.display = 'none';
+                updateMainContainerLayout();
+            });
+        });
+        
+        // 更新主容器布局
+        function updateMainContainerLayout() {
+            // 检查是否有任何插件处于显示状态
+            const isAnyPluginVisible = 
+                codePlugin.style.display === 'flex' || 
+                visualizationPlugin.style.display === 'flex' || 
+                mindmapPlugin.style.display === 'flex';
+            
+            // 更新主容器类名
+            if (isAnyPluginVisible) {
+                mainContainer.classList.add('with-plugin');
+            } else {
+                mainContainer.classList.remove('with-plugin');
+            }
+        }
+        
+        // 发送消息
+        async function sendMessage() {
+            const message = userInput.value.trim();
+            if (!message) return;
+            
+            // 添加用户消息
+            addMessage(message, true);
+            
+            // 清空输入框
+            userInput.value = '';
+            
+            // 禁用发送按钮
+            sendButton.disabled = true;
+            
+            try {
+                // 发送请求
+                const response = await fetch(`/api/student/chat/${agentId}`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                        message: message,
+                        token: token
+                    })
+                });
+                
+                const data = await response.json();
+                
+                if (data.success) {
+                    // 处理回复内容，移除参考来源部分
+                    const processedContent = processResponseContent(data.message);
+                    
+                    // 添加机器人回复
+                    const messageElement = addMessage(processedContent, false);
+                    
+                    // 添加参考信息（如果有）
+                    if (data.references && data.references.length > 0) {
+                        addReferences(messageElement, data.references);
+                    }
+                    
+                    // 检查是否需要显示工具
+                    if (data.tools && data.tools.length > 0) {
+                        // 隐藏所有插件
+                        hideAllPlugins();
+                        
+                        // 使用新的插件激活函数
+                        activatePlugins(data.message, data.tools);
+                    }
+                } else {
+                    // 添加错误消息
+                    addMessage(`错误: ${data.message}`, false);
+                }
+            } catch (error) {
+                console.error('发送请求出错:', error);
+                addMessage('发送请求时出错，请重试', false);
+            } finally {
+                // 恢复发送按钮
+                sendButton.disabled = false;
+            }
+        }
+        
+        // 处理回复内容，移除参考来源部分
+        function processResponseContent(content) {
+            // 移除 "===参考来源开始===" 到 "===参考来源结束===" 之间的内容
+            return content.replace(/===参考来源开始===[\s\S]*?===参考来源结束===/, '');
+        }
+        
+        // 添加参考信息显示函数
+        function addReferences(messageElement, references) {
+            // 创建参考容器
+            const referenceContainer = document.createElement('div');
+            referenceContainer.className = 'reference-container';
+            
+            // 创建参考切换按钮
+            const toggleButton = document.createElement('div');
+            toggleButton.className = 'reference-toggle';
+            toggleButton.textContent = '参考来源';
+            toggleButton.style.color = '#666';
+            toggleButton.style.fontSize = '0.9rem';
+            toggleButton.style.cursor = 'pointer';
+            toggleButton.style.display = 'flex';
+            toggleButton.style.alignItems = 'center';
+            
+            // 创建参考内容
+            const referenceContent = document.createElement('div');
+            referenceContent.className = 'reference-content';
+            
+            // 添加参考项
+            references.forEach(ref => {
+                const refItem = document.createElement('div');
+                refItem.style.marginBottom = '8px';
+                refItem.style.paddingBottom = '8px';
+                refItem.style.borderBottom = '1px solid #eee';
+                
+                refItem.innerHTML = `
+                    <div><strong>[${ref.index}]</strong> ${ref.summary}</div>
+                    <div><small>来源: ${ref.file_name}</small></div>
+                `;
+                
+                referenceContent.appendChild(refItem);
+            });
+            
+            // 添加切换功能
+            toggleButton.addEventListener('click', () => {
+                if (referenceContent.style.display === 'none') {
+                    referenceContent.style.display = 'block';
+                    toggleButton.textContent = '折叠参考来源';
+                } else {
+                    referenceContent.style.display = 'none';
+                    toggleButton.textContent = '参考来源';
+                }
+            });
+            
+            // 组装并添加到消息
+            referenceContainer.appendChild(toggleButton);
+            referenceContainer.appendChild(referenceContent);
+            messageElement.appendChild(referenceContainer);
+        }
+        
+        // 添加消息函数
+        function addMessage(content, isUser) {
+            const messageDiv = document.createElement('div');
+            messageDiv.className = isUser ? 'message user-message' : 'message bot-message';
+            
+            // 处理内容中的换行符和代码块
+            const processedContent = processMessageContent(content);
+            messageDiv.innerHTML = processedContent;
+            
+            chatMessages.appendChild(messageDiv);
+            
+            // 滚动到底部
+            chatMessages.scrollTop = chatMessages.scrollHeight;
+            
+            // 对代码块应用高亮
+            if (!isUser) {
+                applySyntaxHighlighting(messageDiv);
+            }
+            
+            return messageDiv;
+        }
+        
+        // 处理消息内容中的换行符和代码块
+        function processMessageContent(content) {
+            // 先替换代码块，保护它们不受其他替换的影响
+            const codeBlocks = [];
+            let processedContent = content.replace(/```(\w*)\n([\s\S]*?)\n```/g, function(match, language, code) {
+                const id = codeBlocks.length;
+                codeBlocks.push({ language, code });
+                return `__CODE_BLOCK_${id}__`;
+            });
+            
+            // 替换普通换行符
+            processedContent = processedContent.replace(/\n/g, '<br>');
+            
+            // 恢复代码块
+            processedContent = processedContent.replace(/__CODE_BLOCK_(\d+)__/g, function(match, id) {
+                const { language, code } = codeBlocks[id];
+                const langClass = language ? ` class="language-${language}"` : '';
+                return `<pre><code${langClass}>${escapeHtml(code)}</code></pre>`;
+            });
+            
+            return processedContent;
+        }
+        
+        // 应用语法高亮
+        function applySyntaxHighlighting(element) {
+            // 检查是否已加载highlight.js
+            if (typeof hljs !== 'undefined') {
+                // 找出所有代码块并应用高亮
+                element.querySelectorAll('pre code').forEach((block) => {
+                    hljs.highlightBlock(block);
+                });
+            }
+        }
+        
+        // 转义HTML字符
+        function escapeHtml(text) {
+            return text
+                .replace(/&/g, "&amp;")
+                .replace(/</g, "&lt;")
+                .replace(/>/g, "&gt;")
+                .replace(/"/g, "&quot;")
+                .replace(/'/g, "&#039;");
+        }
+        
+        // 隐藏所有插件
+        function hideAllPlugins() {
+            codePlugin.style.display = 'none';
+            visualizationPlugin.style.display = 'none';
+            mindmapPlugin.style.display = 'none';
+            updateMainContainerLayout();
+        }
+        
+        // 提取代码块
+        function extractCodeBlocks(message) {
+            const codeBlocks = [];
+            const codeRegex = /```python\n([\s\S]*?)\n```/g;
+            
+            let match;
+            while ((match = codeRegex.exec(message)) !== null) {
+                codeBlocks.push(match[1]);
+            }
+            
+            return codeBlocks;
+        }
+        
+        // 提取3D可视化函数代码
+        function extract3DVisualizationCode(message) {
+            // 尝试提取函数代码块
+            const codeRegex = /```python\s*(import[\s\S]*?def create_3d_plot\(\):[\s\S]*?return[\s\S]*?})\s*```/i;
+            const match = codeRegex.exec(message);
+            
+            if (match) {
+                return match[1].trim();
+            }
+            
+            return null;
+        }
+        
+        // 提取思维导图内容
+        function extractMindmapContent(message) {
+            // 尝试提取@startmindmap和@endmindmap之间的内容
+            const mindmapRegex = /@startmindmap\n([\s\S]*?)@endmindmap/;
+            const match = mindmapRegex.exec(message);
+            
+            if (match) {
+                return `@startmindmap\n${match[1]}\n@endmindmap`;
+            }
+            
+            return null;
+        }
+        
+        // 激活代码执行插件
+        function activateCodePlugin(message) {
+            // 提取代码块
+            const codeBlocks = extractCodeBlocks(message);
+            
+            if (codeBlocks.length > 0) {
+                const isAlreadyVisible = codePlugin.style.display === 'flex';
+                
+                // 显示插件容器
+                codePlugin.style.display = 'flex';
+                updateMainContainerLayout();
+                
+                // 获取iframe
+                const iframe = document.getElementById('code-execution-frame');
+                
+                // 如果插件已经可见且iframe已加载
+                if (isAlreadyVisible && iframe.contentWindow) {
+                    // 发送新代码到现有iframe
+                    iframe.contentWindow.postMessage({
+                        type: 'setCode',
+                        code: codeBlocks[0]
+                    }, '*');
+                } else {
+                    // 设置iframe源
+                    let src = '/code_execution.html';
+                    if (codeBlocks.length > 0) {
+                        src += `?code=${encodeURIComponent(codeBlocks[0])}`;
+                    }
+                    
+                    iframe.src = src;
+                    
+                    // 设置iframe加载事件处理程序
+                    iframe.onload = function() {
+                        if (codeBlocks.length > 0) {
+                            iframe.contentWindow.postMessage({
+                                type: 'setCode',
+                                code: codeBlocks[0]
+                            }, '*');
+                        }
+                    };
+                }
+            }
+        }
+        
+        // 激活3D可视化插件
+        // 激活3D可视化插件
+function activate3DVisualization(message) {
+    const code = extract3DVisualizationCode(message);
+    
+    if (code) {
+        // 显示插件容器
+        visualizationPlugin.style.display = 'flex';
+        updateMainContainerLayout();
+        
+        // 显示加载状态
+        visualizationResult.innerHTML = `
+            <div class="text-center py-4">
+                <div class="spinner-border text-primary" role="status">
+                    <span class="visually-hidden">生成中...</span>
+                </div>
+                <p class="mt-3">正在生成3D图形，请稍候...</p>
+            </div>
+        `;
+        
+        // 自动生成可视化
+        fetch('/api/visualization/3d-surface', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ code: code })
+        })
+        .then(response => response.json())
+        .then(data => {
+            if (data.success) {
+                // 直接嵌入HTML
+                visualizationResult.innerHTML = `
+                    <div class="visualization-iframe-container" style="width:100%; height:500px;">
+                        <iframe src="${data.html_url}" style="width:100%; height:100%; border:none;"></iframe>
+                    </div>
+                    <div class="text-center mt-3">
+                        <p>3D图形生成成功</p>
+                        <a href="${data.html_url}" class="btn btn-sm btn-outline-primary" target="_blank">
+                            <i class="bi bi-arrows-fullscreen"></i> 全屏查看
+                        </a>
+                    </div>
+                `;
+            } else {
+                visualizationResult.innerHTML = `
+                    <div class="alert alert-danger">
+                        <i class="bi bi-exclamation-triangle-fill me-2"></i>
+                        生成失败: ${data.message}
+                    </div>
+                `;
+            }
+        })
+        .catch(error => {
+            console.error('生成3D图形出错:', error);
+            visualizationResult.innerHTML = `
+                <div class="alert alert-danger">
+                    <i class="bi bi-exclamation-triangle-fill me-2"></i>
+                    生成3D图形时发生错误，请重试
+                </div>
+            `;
+        });
+    }
+}
+        // 激活思维导图插件
+        function activateMindmap(message) {
+            const content = extractMindmapContent(message);
+            
+            if (content) {
+                // 显示插件容器
+                mindmapPlugin.style.display = 'flex';
+                updateMainContainerLayout();
+                
+                // 显示加载状态
+                mindmapResult.innerHTML = `
+                    <div class="text-center py-4">
+                        <div class="spinner-border text-primary" role="status">
+                            <span class="visually-hidden">生成中...</span>
+                        </div>
+                        <p class="mt-3">正在生成思维导图，请稍候...</p>
+                    </div>
+                `;
+                
+                // 自动生成思维导图
+                fetch('/api/visualization/mindmap', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ content: content })
+                })
+                .then(response => response.json())
+                .then(data => {
+                    if (data.success) {
+                        mindmapResult.innerHTML = `
+                            <div class="text-center">
+                                <img src="${data.url}" class="mindmap-image" alt="思维导图">
+                                <p class="mt-3">生成成功！</p>
+                            </div>
+                        `;
+                    }
+                else {
+                        mindmapResult.innerHTML = `
+                            <div class="alert alert-danger">
+                                <i class="bi bi-exclamation-triangle-fill me-2"></i>
+                                生成失败: ${data.message}
+                            </div>
+                        `;
+                    }
+                })
+                .catch(error => {
+                    console.error('生成思维导图出错:', error);
+                    mindmapResult.innerHTML = `
+                        <div class="alert alert-danger">
+                            <i class="bi bi-exclamation-triangle-fill me-2"></i>
+                            生成思维导图时发生错误，请重试
+                        </div>
+                    `;
+                });
+            }
+        }
+        
+        // 根据消息内容激活适当的插件
+        function activatePlugins(message, tools) {
+            // 检查并激活代码执行插件
+            if (tools.includes('code') && message.includes('```python')) {
+                activateCodePlugin(message);
+            }
+            
+            // 检查并激活3D可视化插件
+            if (tools.includes('visualization') && 
+                (message.includes('def create_3d_plot') || 
+                 message.includes('3D') || message.includes('可视化'))) {
+                activate3DVisualization(message);
+            }
+            
+            // 检查并激活思维导图插件
+            if (tools.includes('mindmap') && 
+                (message.includes('@startmindmap') || 
+                 message.includes('思维导图'))) {
+                activateMindmap(message);
+            }
+        }
+    </script>
+    
+    <!-- 添加highlight.js用于代码高亮 -->
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.8.0/highlight.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.8.0/languages/python.min.js"></script>
+    <script>
+        // 初始化代码高亮
+        document.addEventListener('DOMContentLoaded', function() {
+            if (typeof hljs !== 'undefined') {
+                hljs.configure({
+                    languages: ['python']
+                });
+            }
+        });
+    </script>
+</body>
+</html>

utils/helpers.py

@@ -0,0 +1,80 @@
+# utils/helpers.py
+import os
+import json
+import time
+import re
+
+def create_response(success, message="", data=None, status_code=200):
+    """创建标准化的API响应"""
+    response = {"success": success}
+    
+    if message:
+        response["message"] = message
+        
+    if data is not None:
+        response["data"] = data
+        
+    return response, status_code
+
+def validate_agent_access(agent_id, token=None):
+    """验证Agent访问权限"""
+    agent_path = os.path.join('agents', f"{agent_id}.json")
+    
+    if not os.path.exists(agent_path):
+        return False, "Agent不存在"
+    
+    try:
+        with open(agent_path, 'r', encoding='utf-8') as f:
+            agent_config = json.load(f)
+            
+        # 如果没有提供令牌，则允许访问
+        if not token:
+            return True, agent_config
+            
+        # 验证令牌
+        if "distributions" in agent_config:
+            for dist in agent_config["distributions"]:
+                if dist.get("token") == token:
+                    # 检查是否过期
+                    if dist.get("expires_at", 0) > 0 and dist.get("expires_at", 0) < time.time():
+                        return False, "访问令牌已过期"
+                    
+                    # 更新使用计数
+                    dist["usage_count"] = dist.get("usage_count", 0) + 1
+                    
+                    # 更新Agent使用统计
+                    if "stats" not in agent_config:
+                        agent_config["stats"] = {}
+                    
+                    agent_config["stats"]["usage_count"] = agent_config["stats"].get("usage_count", 0) + 1
+                    agent_config["stats"]["last_used"] = int(time.time())
+                    
+                    # 保存更新后的配置
+                    with open(agent_path, 'w', encoding='utf-8') as f:
+                        json.dump(agent_config, f, ensure_ascii=False, indent=2)
+                    
+                    return True, agent_config
+            
+        return False, "访问令牌无效"
+        
+    except Exception as e:
+        return False, f"验证过程出错: {str(e)}"
+
+def extract_code_from_text(text):
+    """从文本中提取代码块"""
+    # 尝试找到Python代码块
+    pattern = r'```(?:python)?\n([\s\S]*?)\n```'
+    match = re.search(pattern, text)
+    
+    if match:
+        return match.group(1)
+    
+    # 如果没有找到带有语言标记的代码块，尝试无语言标记的
+    pattern = r'```\n([\s\S]*?)\n```'
+    match = re.search(pattern, text)
+    
+    if match:
+        return match.group(1)
+    
+    # 如果没有代码块标记，返回原始文本
+    return text