ChatGLM3-6B-128K与MySQL集成：企业知识库构建方案

想象一下，公司新来的同事问你：“咱们产品的技术架构文档在哪里？客户去年提出的那个特殊需求是怎么处理的？”你可能会花上半天时间，在共享盘、邮件、聊天记录和各种文档系统里翻找。这几乎是每个企业都会遇到的痛点——知识散落在各处，用的时候找不到。

现在，我们可以换个思路：让一个AI助手来帮你记住这一切。它不仅能记住，还能理解你的问题，从海量资料里找到最相关的信息，用自然语言告诉你答案。这就是我们今天要聊的，用ChatGLM3-6B-128K和MySQL搭建企业知识库的核心价值。

1. 为什么选择这个组合？

在开始动手之前，我们先聊聊为什么是ChatGLM3-6B-128K和MySQL。

ChatGLM3-6B-128K最大的特点就是能处理超长的文本。128K的上下文长度是什么概念？差不多能放下9万个汉字，或者120页A4纸的纯文本。这意味着你可以把整份产品需求文档、技术白皮书、甚至是一年的会议纪要都喂给它，它都能“读”得进去，并且理解其中的关联。

而MySQL，大家太熟悉了。几乎每个公司的业务系统背后都有它的身影，稳定、可靠，团队里随便拉个人出来都会用。把知识存在MySQL里，意味着你可以很方便地和你现有的CRM、ERP、OA系统打通，数据同步和管理都变得简单。

这个组合的妙处就在于：ChatGLM3-6B-128K负责“理解”和“回答”，扮演聪明的大脑；MySQL负责“记忆”和“存储”，扮演可靠的大仓库。大脑不需要记住所有细节，只需要知道去仓库的哪个货架上取东西就行。

2. 第一步：把你的知识“喂”给系统

构建知识库的第一步，是把散落各处的文档、数据整理好，存进MySQL。这个过程我们叫数据导入，但绝不是简单地把文件内容复制粘贴进数据库。

2.1 设计知识存储的结构

在MySQL里，我们至少需要两张核心表：

第一张表存放知识的“元信息”，就像图书馆的图书卡片。

CREATE TABLE knowledge_base (
    id INT PRIMARY KEY AUTO_INCREMENT,
    title VARCHAR(255) NOT NULL COMMENT '知识标题，如：产品安装指南',
    content_type VARCHAR(50) COMMENT '内容类型：文档、QA、代码片段等',
    source VARCHAR(255) COMMENT '来源：如Confluence链接、文件路径',
    category VARCHAR(100) COMMENT '分类：技术、产品、市场等',
    keywords TEXT COMMENT '关键词，用于快速检索',
    raw_content LONGTEXT COMMENT '原始文本内容',
    embedding_vector BLOB COMMENT '向量化后的内容，用于语义搜索',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

第二张表记录知识之间的关联，比如某份操作手册引用了某个API文档。

CREATE TABLE knowledge_relations (
    id INT PRIMARY KEY AUTO_INCREMENT,
    source_id INT NOT NULL COMMENT '源知识ID',
    target_id INT NOT NULL COMMENT '目标知识ID',
    relation_type VARCHAR(50) COMMENT '关联类型：引用、依赖、相似等',
    FOREIGN KEY (source_id) REFERENCES knowledge_base(id),
    FOREIGN KEY (target_id) REFERENCES knowledge_base(id)
);

2.2 从各种来源导入数据

数据通常来自好几个地方，我们需要写一些脚本来处理。下面是一个Python示例，展示如何从本地文本文件导入：

import os
import mysql.connector
from mysql.connector import Error

def import_text_files_to_db(directory_path, category):
    """将指定目录下的文本文件导入知识库"""
    
    # 连接MySQL数据库
    try:
        connection = mysql.connector.connect(
            host='localhost',
            database='company_knowledge',
            user='your_username',
            password='your_password'
        )
        
        cursor = connection.cursor()
        
        # 遍历目录下的所有.txt文件
        for filename in os.listdir(directory_path):
            if filename.endswith('.txt'):
                filepath = os.path.join(directory_path, filename)
                
                with open(filepath, 'r', encoding='utf-8') as file:
                    content = file.read()
                
                # 简单提取标题（使用文件名或内容第一行）
                title = filename.replace('.txt', '')
                
                # 插入数据库
                insert_query = """
                INSERT INTO knowledge_base 
                (title, content_type, category, raw_content) 
                VALUES (%s, %s, %s, %s)
                """
                
                cursor.execute(insert_query, 
                             (title, 'document', category, content))
                
                print(f"已导入: {filename}")
        
        connection.commit()
        print("所有文件导入完成！")
        
    except Error as e:
        print(f"数据库错误: {e}")
    finally:
        if connection.is_connected():
            cursor.close()
            connection.close()

# 使用示例：导入技术文档
import_text_files_to_db('/path/to/tech_docs', '技术文档')

如果是更结构化的数据，比如从Confluence、Notion或者公司自建的Wiki导出，通常会有API可以直接调用，导入效率会更高。关键是要保持数据的“干净”，把无关的格式标记、图片引用清理掉，保留核心的文本内容。

3. 第二步：让AI理解并检索知识

数据存好了，接下来是关键：怎么让ChatGLM3-6B-128K从这些数据里找到答案？直接让AI模型去读MySQL里的每一行数据是不现实的，效率太低。我们需要一个“中间人”——这就是向量检索。

3.1 将文本转换为向量

简单说，就是把一段文字变成一串数字（向量），语义相近的文字，它们的数字串在数学空间里的位置也相近。ChatGLM3本身就可以帮我们做这个转换。

我们先写一个函数，用ChatGLM3把知识库里的内容都转换成向量：

import numpy as np
from typing import List
import mysql.connector

class KnowledgeEmbedder:
    def __init__(self, model_name='chatglm3-6b-128k'):
        # 这里初始化ChatGLM3模型
        # 实际部署时可能需要根据你的环境调整
        self.model = self.load_model(model_name)
    
    def load_model(self, model_name):
        """加载ChatGLM3模型"""
        # 示例代码，实际实现取决于你的部署方式
        # 可能是通过Ollama、Transformers库等
        print(f"正在加载模型: {model_name}")
        # 返回模型实例
        return None  # 实际使用时替换为真实的模型加载
    
    def generate_embedding(self, text: str) -> List[float]:
        """生成文本的向量表示"""
        # 这里调用ChatGLM3的嵌入功能
        # 简化示例：实际需要调用模型的embedding接口
        # 假设我们得到一个384维的向量
        embedding = [0.1, 0.2, ...]  # 实际由模型生成
        return embedding
    
    def batch_embed_knowledge(self, batch_size=10):
        """批量处理知识库中的内容，生成向量"""
        
        connection = mysql.connector.connect(
            host='localhost',
            database='company_knowledge',
            user='your_username',
            password='your_password'
        )
        cursor = connection.cursor(dictionary=True)
        
        # 获取尚未生成向量的知识条目
        cursor.execute("SELECT id, raw_content FROM knowledge_base WHERE embedding_vector IS NULL LIMIT %s", (batch_size,))
        rows = cursor.fetchall()
        
        for row in rows:
            content = row['raw_content']
            if content and len(content) > 10:  # 简单过滤空内容
                embedding = self.generate_embedding(content)
                
                # 将向量存储为二进制
                embedding_bytes = np.array(embedding, dtype=np.float32).tobytes()
                
                update_cursor = connection.cursor()
                update_cursor.execute(
                    "UPDATE knowledge_base SET embedding_vector = %s WHERE id = %s",
                    (embedding_bytes, row['id'])
                )
                update_cursor.close()
                
                print(f"已生成向量: ID {row['id']}")
        
        connection.commit()
        cursor.close()
        connection.close()

3.2 搭建语义检索接口

有了向量之后，当用户提问时，我们先把问题也转换成向量，然后在数据库里找和这个问题向量最接近的那些知识向量。

class KnowledgeRetriever:
    def __init__(self, embedder):
        self.embedder = embedder
    
    def search_similar_knowledge(self, query: str, top_k=5):
        """根据查询语句检索最相关的知识"""
        
        # 1. 将查询转换为向量
        query_embedding = self.embedder.generate_embedding(query)
        query_vector = np.array(query_embedding, dtype=np.float32)
        
        connection = mysql.connector.connect(
            host='localhost',
            database='company_knowledge',
            user='your_username',
            password='your_password'
        )
        cursor = connection.cursor(dictionary=True)
        
        # 2. 获取所有知识的向量（实际生产环境需要优化，这里用简单示例）
        cursor.execute("SELECT id, title, raw_content, embedding_vector FROM knowledge_base WHERE embedding_vector IS NOT NULL")
        all_knowledge = cursor.fetchall()
        
        similarities = []
        
        for item in all_knowledge:
            # 从二进制数据恢复向量
            stored_vector = np.frombuffer(item['embedding_vector'], dtype=np.float32)
            
            # 3. 计算余弦相似度
            similarity = np.dot(query_vector, stored_vector) / (
                np.linalg.norm(query_vector) * np.linalg.norm(stored_vector)
            )
            
            similarities.append({
                'id': item['id'],
                'title': item['title'],
                'content': item['raw_content'][:200] + '...',  # 截取预览
                'similarity': float(similarity)
            })
        
        # 4. 按相似度排序，返回最相关的结果
        similarities.sort(key=lambda x: x['similarity'], reverse=True)
        
        cursor.close()
        connection.close()
        
        return similarities[:top_k]

# 使用示例
embedder = KnowledgeEmbedder()
retriever = KnowledgeRetriever(embedder)

# 当用户提问时
question = "产品出现错误代码500应该怎么处理？"
results = retriever.search_similar_knowledge(question)

print(f"问题: {question}")
print("相关结果:")
for result in results:
    print(f"- [{result['title']}] 相似度: {result['similarity']:.3f}")
    print(f"  内容: {result['content']}")

在实际生产环境中，当知识量很大时（比如超过10万条），直接在MySQL里做向量相似度计算会很慢。这时候可以考虑专门的向量数据库（比如Milvus、Qdrant），或者使用MySQL的向量检索扩展。但对于大多数中小企业来说，初期几万条知识用上述方法完全够用。

4. 第三步：用自然语言回答用户问题

找到了相关的知识片段，最后一步就是让ChatGLM3把这些信息组织成通顺、有用的回答。

4.1 构建智能问答接口

我们创建一个问答服务，它做的事情很清晰：接收问题，检索相关知识，让AI生成回答。

from flask import Flask, request, jsonify
import json

app = Flask(__name__)

class KnowledgeQASystem:
    def __init__(self):
        self.embedder = KnowledgeEmbedder()
        self.retriever = KnowledgeRetriever(self.embedder)
        # 这里初始化ChatGLM3的对话模型
        self.chat_model = self.load_chat_model()
    
    def load_chat_model(self):
        """加载ChatGLM3对话模型"""
        # 实际部署代码
        print("加载对话模型中...")
        return None  # 替换为实际模型
    
    def generate_answer(self, question: str, context_knowledge: list) -> str:
        """基于检索到的知识生成回答"""
        
        # 构建给AI的提示词
        prompt = f"""你是一个企业知识库助手，请根据以下提供的相关知识，回答用户的问题。

相关参考知识：
{json.dumps(context_knowledge, ensure_ascii=False, indent=2)}

用户问题：{question}

请根据上述知识给出准确、有用的回答。如果知识中没有相关信息，请如实告知“根据现有知识库，我无法找到相关信息”。
回答时请使用中文，语气友好专业。"""
        
        # 调用ChatGLM3生成回答
        # 这里简化了实际调用过程
        answer = "这是一个基于知识的示例回答。"  # 实际由模型生成
        
        return answer
    
    def ask_question(self, question: str) -> dict:
        """处理用户提问的完整流程"""
        
        # 1. 检索相关知识
        relevant_knowledge = self.retriever.search_similar_knowledge(question, top_k=3)
        
        # 提取知识内容用于生成回答
        context_list = []
        for item in relevant_knowledge:
            context_list.append({
                'title': item['title'],
                'content': item['content']
            })
        
        # 2. 生成回答
        answer = self.generate_answer(question, context_list)
        
        # 3. 返回结果
        return {
            'question': question,
            'answer': answer,
            'sources': relevant_knowledge,
            'timestamp': datetime.now().isoformat()
        }

# 初始化系统
qa_system = KnowledgeQASystem()

@app.route('/api/ask', methods=['POST'])
def ask_knowledge():
    """问答API接口"""
    data = request.json
    question = data.get('question', '')
    
    if not question:
        return jsonify({'error': '请提供问题内容'}), 400
    
    try:
        result = qa_system.ask_question(question)
        return jsonify(result)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/search', methods=['GET'])
def search_knowledge():
    """纯检索API接口，只返回相关知识，不生成回答"""
    query = request.args.get('q', '')
    
    if not query:
        return jsonify({'error': '请提供查询内容'}), 400
    
    try:
        results = qa_system.retriever.search_similar_knowledge(query)
        return jsonify({'query': query, 'results': results})
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)

这个API提供了两个端点：/api/ask 会返回完整的AI生成答案，适合直接面向最终用户；/api/search 只返回检索到的相关知识，适合需要人工审核或进一步处理的场景。

4.2 实际使用案例

假设我们是一家SaaS软件公司，知识库里已经导入了产品文档、技术FAQ和客户支持记录。现在有客户支持人员收到一个问题：

“客户反映在导出报表时，系统提示‘内存不足’，请问可能的原因和解决方案是什么？”

支持人员在内部系统里输入这个问题，系统后台的运作流程是这样的：

1. 问题被发送到 /api/ask 接口
2. 系统将问题转换为向量，在MySQL知识库中搜索
3. 找到了三篇相关文档：
   • 《报表导出性能优化指南》相似度0.87
   • 《常见错误代码及解决方法》相似度0.76
   • 《系统硬件要求说明》相似度0.68
4. ChatGLM3收到问题和这三篇文档的内容，生成回答：

   “根据知识库资料，报表导出时提示‘内存不足’可能的原因有：1. 导出的数据量过大，超过单次处理限制；2. 服务器可用内存不足；3. 浏览器缓存积累过多。建议解决方案：1. 尝试分批次导出数据；2. 检查服务器内存使用情况，必要时重启服务；3. 清理浏览器缓存或尝试使用无痕模式。详细步骤可参考《报表导出性能优化指南》第3.2节。”

这个回答不仅给出了原因和方案，还指明了参考文档，支持人员可以直接把回答发给客户，或者根据指引进一步排查。

5. 第四步：让知识库“活”起来

知识库建好了，但如果不能持续更新，很快就会过时。我们需要一个机制，让知识库能够与时俱进。

5.1 设计知识更新流程

更新知识库不是简单的新增记录，还要考虑旧知识的失效、关联知识的同步等问题。

class KnowledgeUpdater:
    def __init__(self):
        self.embedder = KnowledgeEmbedder()
    
    def add_new_knowledge(self, title, content, category, source=None):
        """添加新的知识条目"""
        
        connection = mysql.connector.connect(
            host='localhost',
            database='company_knowledge',
            user='your_username',
            password='your_password'
        )
        cursor = connection.cursor()
        
        # 生成向量
        embedding = self.embedder.generate_embedding(content)
        embedding_bytes = np.array(embedding, dtype=np.float32).tobytes()
        
        # 插入新知识
        insert_query = """
        INSERT INTO knowledge_base 
        (title, raw_content, category, source, embedding_vector) 
        VALUES (%s, %s, %s, %s, %s)
        """
        
        cursor.execute(insert_query, (title, content, category, source, embedding_bytes))
        new_id = cursor.lastrowid
        
        # 自动关联相似知识（可选功能）
        self.auto_link_related_knowledge(new_id, embedding)
        
        connection.commit()
        cursor.close()
        connection.close()
        
        print(f"新知识已添加，ID: {new_id}")
        return new_id
    
    def auto_link_related_knowledge(self, new_id, new_embedding):
        """自动关联相似的知识条目"""
        # 实现逻辑：找到向量相似度超过阈值的老知识，建立关联
        # 这里省略具体实现
        pass
    
    def update_existing_knowledge(self, knowledge_id, new_content):
        """更新已有知识"""
        
        connection = mysql.connector.connect(
            host='localhost',
            database='company_knowledge',
            user='your_username',
            password='your_password'
        )
        cursor = connection.cursor()
        
        # 重新生成向量
        new_embedding = self.embedder.generate_embedding(new_content)
        embedding_bytes = np.array(new_embedding, dtype=np.float32).tobytes()
        
        # 更新记录
        update_query = """
        UPDATE knowledge_base 
        SET raw_content = %s, embedding_vector = %s, updated_at = CURRENT_TIMESTAMP 
        WHERE id = %s
        """
        
        cursor.execute(update_query, (new_content, embedding_bytes, knowledge_id))
        
        # 标记关联知识可能需要重新评估（通过一个标记字段）
        cursor.execute(
            "UPDATE knowledge_relations SET needs_review = 1 WHERE target_id = %s OR source_id = %s",
            (knowledge_id, knowledge_id)
        )
        
        connection.commit()
        cursor.close()
        connection.close()
        
        print(f"知识ID {knowledge_id} 已更新")
    
    def deprecate_knowledge(self, knowledge_id, reason):
        """标记知识为过时"""
        
        connection = mysql.connector.connect(
            host='localhost',
            database='company_knowledge',
            user='your_username',
            password='your_password'
        )
        cursor = connection.cursor()
        
        # 不是物理删除，而是标记状态
        cursor.execute(
            "UPDATE knowledge_base SET is_deprecated = 1, deprecation_reason = %s WHERE id = %s",
            (reason, knowledge_id)
        )
        
        # 检索时可以通过过滤 is_deprecated = 0 来排除过时知识
        connection.commit()
        cursor.close()
        connection.close()
        
        print(f"知识ID {knowledge_id} 已标记为过时")

5.2 建立更新触发机制

知识更新可以来自多个渠道：

1. 人工维护：知识管理员定期审核和更新
2. 系统同步：与Confluence、Notion等系统同步更新
3. 用户反馈：根据用户对回答的评分和反馈，识别需要更新的知识
4. 自动发现：定期扫描公司文档库，发现新文档或旧文档更新

这里给出一个简单的用户反馈驱动更新示例：

class FeedbackDrivenUpdater:
    def __init__(self):
        self.connection = mysql.connector.connect(
            host='localhost',
            database='company_knowledge',
            user='your_username',
            password='your_password'
        )
    
    def record_user_feedback(self, question_id, answer_id, feedback_score, user_comment=None):
        """记录用户对回答的反馈"""
        
        cursor = self.connection.cursor()
        
        insert_feedback = """
        INSERT INTO answer_feedback 
        (question_id, answer_id, feedback_score, user_comment) 
        VALUES (%s, %s, %s, %s)
        """
        
        cursor.execute(insert_feedback, (question_id, answer_id, feedback_score, user_comment))
        
        # 如果反馈很差（比如评分低于2分/5分制），触发知识审查
        if feedback_score < 2:
            self.flag_knowledge_for_review(answer_id, user_comment)
        
        self.connection.commit()
        cursor.close()
    
    def flag_knowledge_for_review(self, answer_id, reason):
        """标记相关知识需要人工审查"""
        
        cursor = self.connection.cursor()
        
        # 找到这个回答引用的知识来源
        cursor.execute(
            "SELECT knowledge_id FROM answer_sources WHERE answer_id = %s",
            (answer_id,)
        )
        knowledge_ids = [row[0] for row in cursor.fetchall()]
        
        # 标记这些知识需要审查
        for k_id in knowledge_ids:
            cursor.execute(
                "UPDATE knowledge_base SET needs_human_review = 1, review_reason = %s WHERE id = %s",
                (f"用户反馈: {reason}", k_id)
            )
        
        self.connection.commit()
        cursor.close()
        print(f"已标记 {len(knowledge_ids)} 条知识需要人工审查")

6. 实际部署考虑和优化建议

走通了整个流程，但在真正用到公司环境前，还有一些实际问题需要考虑。

6.1 性能优化

当知识量增长到数万条时，简单的全表扫描计算向量相似度会变得很慢。可以考虑以下优化：

1. 使用向量索引：MySQL 8.0以上版本支持向量类型的索引，可以显著加速相似度查询
2. 分块存储：对于长文档，不要整篇存为一个向量，而是按段落或章节拆分，分别存储向量
3. 缓存机制：常见问题的检索结果可以缓存一段时间，减少重复计算
4. 异步处理：向量生成这种耗时操作可以放到后台任务队列中处理

6.2 权限和安全性

企业知识库通常包含敏感信息，不能对所有人开放所有内容。

class SecureKnowledgeAccess:
    def __init__(self):
        self.connection = mysql.connector.connect(
            host='localhost',
            database='company_knowledge',
            user='your_username',
            password='your_password'
        )
    
    def search_with_permission(self, query: str, user_id: int, top_k=5):
        """考虑用户权限的知识检索"""
        
        cursor = self.connection.cursor(dictionary=True)
        
        # 先检索相关知识点
        # 这里简化了向量检索部分，聚焦权限过滤
        base_query = """
        SELECT kb.*, 
               (MATCH(kb.raw_content) AGAINST(%s IN NATURAL LANGUAGE MODE)) as relevance
        FROM knowledge_base kb
        LEFT JOIN knowledge_permissions kp ON kb.id = kp.knowledge_id
        WHERE (kp.department_id IN (SELECT department_id FROM users WHERE id = %s)
               OR kp.user_id = %s 
               OR kb.is_public = 1)
          AND kb.is_deprecated = 0
        ORDER BY relevance DESC
        LIMIT %s
        """
        
        cursor.execute(base_query, (query, user_id, user_id, top_k))
        results = cursor.fetchall()
        
        cursor.close()
        return results

6.3 监控和维护

上线后需要关注几个关键指标：

• 问答响应时间（目标：<3秒）
• 回答准确率（通过用户反馈统计）
• 知识库覆盖率（用户问题有多少能在知识库中找到答案）
• 系统资源使用（CPU、内存、数据库连接数）

可以设置一个简单的监控面板：

class KnowledgeBaseMonitor:
    def collect_daily_metrics(self):
        """收集每日使用指标"""
        
        cursor = self.connection.cursor(dictionary=True)
        
        metrics = {}
        
        # 总知识量
        cursor.execute("SELECT COUNT(*) as total FROM knowledge_base WHERE is_deprecated = 0")
        metrics['total_knowledge'] = cursor.fetchone()['total']
        
        # 今日问答量
        cursor.execute("""
            SELECT COUNT(*) as today_qa 
            FROM query_log 
            WHERE DATE(created_at) = CURDATE()
        """)
        metrics['today_qa_count'] = cursor.fetchone()['today_qa']
        
        # 平均回答满意度
        cursor.execute("""
            SELECT AVG(feedback_score) as avg_score 
            FROM answer_feedback 
            WHERE DATE(created_at) = CURDATE()
        """)
        metrics['avg_satisfaction'] = cursor.fetchone()['avg_score'] or 0
        
        # 无法回答的问题比例
        cursor.execute("""
            SELECT 
                SUM(CASE WHEN has_answer = 0 THEN 1 ELSE 0 END) as no_answer,
                COUNT(*) as total
            FROM query_log 
            WHERE DATE(created_at) = CURDATE()
        """)
        row = cursor.fetchone()
        metrics['no_answer_rate'] = row['no_answer'] / row['total'] if row['total'] > 0 else 0
        
        cursor.close()
        return metrics

7. 总结

把ChatGLM3-6B-128K和MySQL结合起来构建企业知识库，本质上是在做两件事：一是把非结构化的文档、对话、资料变成机器能理解的结构化知识；二是让AI学会用人类的方式，把这些知识重新组织成有用的回答。

这套方案的好处很明显：部署相对简单，技术栈都是大家熟悉的，效果却立竿见影。员工不用再花大量时间找资料，客户问题能更快得到准确回答，企业的知识资产也真正被盘活起来。

实际落地时，建议从小范围开始，比如先聚焦某个部门或某个产品线的知识，跑通流程、看到效果后，再逐步扩大范围。过程中肯定会遇到各种具体问题，比如文档格式混乱、知识关联复杂、权限设置繁琐等，但这些都是可以一步步解决的工程问题。

最关键的是迈出第一步：选一个最痛的场景，把第一批知识灌进去，让第一个员工用起来。看到AI真的能帮上忙，后面的推进就会顺利很多。

---

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。