项目地址: Gitee
技术栈: Node.js + Express + HTML5 + TailwindCSS + DeepSeek AI
开发时间: 2026 年
作者: [翎洛洛]

📖 目录

💡 初心：为什么做这个项目

痛点洞察

作为一名游戏开发爱好者，我观察到几个普遍存在的问题：

  1. 创意难以落地：很多人有绝佳的游戏创意，但不知道如何开始实现
  2. 技术选型困难：面对 C++、Python、Unity、Unreal 等众多技术栈，初学者无从选择
  3. AI 工具使用门槛：虽然有了 Cursor 等 AI 编程工具，但很多人不会写高质量的提示词
  4. 知识碎片化：游戏开发涉及的知识太分散，缺乏系统性的引导

项目愿景

打造一个 AI 驱动的游戏开发引导平台，让任何人都能将游戏创意快速转化为可执行的项目计划，并获得最适合的技术栈推荐和 AI 编码提示词。

这个平台要像一位经验丰富的游戏开发导师，通过多轮对话理解你的想法，给出专业建议，并生成可直接使用的开发文档和代码提示。

🏗️ 第一阶段：核心构想与 MVP

核心设计理念

项目最初的核心是一个基于 LLM Wiki 的多轮对话系统，包含三个关键创新：

1. 分层规则系统
规则层级：
├── 用户规则 (User Rules) - 用户的个人偏好
├── 项目规则 (Project Rules) - 当前项目的特定规则
├── Skill - 可复用的功能模块
├── 全局规范 (Global Specs) - 通用开发规范
└── 内置 Agent - 5 个专业角色

这种设计让系统既能理解用户的个性化需求，又能保持专业性。

2. 状态机驱动的对话流程
init → clarify_gameplay → clarify_art → brainstorm → task_breakdown → done

每个阶段都有明确的目标和输出，确保对话始终朝着可执行的结果推进。

3. 规范学习引擎

系统能从用户的反馈中自动提取规范，形成可复用的知识库。例如，当用户说"我不喜欢复杂的物理系统"，系统会记录这个偏好，并在后续建议中避免复杂的物理实现。

MVP 功能清单

  • ✅ 基础对话界面
  • ✅ 5 个内置 Agent（策划、架构、程序员、QA、艺术家）
  • ✅ 状态机管理对话流程
  • ✅ 简单的规则存储
  • ✅ Cursor 规则生成

第一个版本代码（简化版）

// server.js - 最初的版本
const sessions = new Map();

app.post('/api/start', async (req, res) => {
  const { idea } = req.body;
  const sessionId = uuidv4();
  
  sessions.set(sessionId, {
    id: sessionId,
    gameIdea: idea,
    stage: 'init',
    history: []
  });
  
  // 调用 LLM 生成响应
  const response = await callLLM(idea);
  
  res.json({ sessionId, message: response });
});

这个简单版本只有 200 行代码，但验证了核心概念的可行性。

🤖 第二阶段：多智能体系统

Agent 架构设计

随着项目发展，我意识到需要更专业的角色分工。于是设计了 5 个内置 Agent：

1. 策划 Agent (Planner)
  • 职责：完善游戏创意，设计核心玩法
  • 提示词重点：
    • 核心机制是什么？
    • 玩家目标是什么？
    • 游戏循环如何设计？
2. 架构 Agent (Architect)
  • 职责：设计技术架构和模块划分
  • 提示词重点：
    • 使用什么设计模式？
    • 模块如何解耦？
    • 数据流如何设计？
3. 程序员 Agent (Programmer)
  • 职责：生成具体代码实现
  • 提示词重点：
    • 代码规范和最佳实践
    • 性能优化建议
    • 错误处理
4. QA Agent (质量保证)
  • 职责：测试用例和边界情况
  • 提示词重点：
    • 边界条件检查
    • 异常场景处理
    • 性能测试建议
5. 艺术家 Agent (Artist)
  • 职责：美术风格和资源规划
  • 提示词重点：
    • 色彩搭配
    • 视觉风格统一
    • 资源优化

Agent 切换机制

系统根据对话阶段自动切换主导 Agent：

const AGENT_FLOW = {
  'init': 'planner',
  'clarify_gameplay': 'planner',
  'clarify_art': 'artist',
  'brainstorm': 'planner',
  'task_breakdown': 'architect',
  'done': 'programmer'
};

Skill 系统诞生

为了让功能可复用，我设计了 Skill 系统：

# platformer_jump_skill.yaml
name: platformer_jump_skill
description: 平台跳跃游戏跳跃机制实现
category: gameplay
tags: [platformer, jump, physics]

inputs:
  - name: jump_height
    type: number
    default: 100
  - name: gravity
    type: number
    default: 9.8

prompt: |
  实现一个平台跳跃游戏的跳跃系统，要求：
  1. 跳跃高度：{{jump_height}} 像素
  2. 重力加速度：{{gravity}}
  3. 支持二段跳
  4. 落地检测

用户可以在对话中使用 @skill platformer_jump 来引用特定技能，系统会自动将 Skill 的提示词模板注入到上下文中。

🌍 第三阶段：全栈扩展

从 Web 游戏到全平台

用户反馈说：“这个工具只能做网页游戏吗？我想做 C++ 游戏、Unity 游戏…”

这促使我做出了最重要的升级：支持多种技术栈。

技术栈配置系统

我创建了一个完整的技术栈数据库：

{
  "cpp": {
    "name": "C++",
    "description": "高性能游戏开发，适合 AAA 级游戏",
    "performance": "极高",
    "learning_curve": "陡峭",
    "best_for": ["3D 游戏", "大型游戏", "游戏引擎"],
    "frameworks": [
      {"name": "Unreal Engine", "type": "engine"},
      {"name": "SFML", "type": "library"},
      {"name": "SDL2", "type": "library"},
      {"name": "Raylib", "type": "library"}
    ]
  },
  "python": {
    "name": "Python",
    "description": "简单易学，适合原型开发",
    "performance": "中等",
    "learning_curve": "简单",
    "best_for": ["2D 游戏", "原型", "教育"],
    "frameworks": [
      {"name": "Pygame", "type": "library"},
      {"name": "Arcade", "type": "library"},
      {"name": "Panda3D", "type": "engine"}
    ]
  }
  // ... Java, C#, JavaScript, C
}

智能推荐引擎

基于多维度评分的推荐算法：

async recommend(options) {
  const scores = {};
  
  // 游戏类型匹配
  typeMatches.forEach(match => {
    match.recommended.forEach(stack => {
      scores[stack].gameTypeBonus += 20;
    });
  });
  
  // 平台匹配
  targetPlatforms.forEach(platform => {
    platformInfo.supported_stacks.forEach(stack => {
      scores[stack].platformBonus += 15;
    });
  });
  
  // 团队规模调整
  if (teamSize === 'solo') {
    scores.python.experienceBonus += 10;
    scores.javascript.experienceBonus += 10;
  }
  
  // 计算总分并排序
  return recommendations.sort((a, b) => b.score - a.score);
}

推荐逻辑示例：

场景 推荐 原因
独立开发者，初学者，2D 游戏 Python + Pygame 学习曲线平缓，开发快
小团队，有经验，3D 游戏 C# + Unity 强大引擎，跨平台
大团队，AAA 级 FPS C++ + Unreal 极致性能，行业标准
快速原型验证 JavaScript + Phaser 最快开发速度

项目模板生成器

一键生成完整的项目结构：

// project_template_generator.js
generateCppSfml() {
  return {
    files: [
      {
        path: 'CMakeLists.txt',
        content: `cmake_minimum_required(VERSION 3.10)
project({{projectName}})
set(CMAKE_CXX_STANDARD 17)
find_package(SFML 2.5 COMPONENTS graphics window system REQUIRED)
add_executable({{projectName}} src/main.cpp)
target_link_libraries({{projectName}} sfml-graphics sfml-window sfml-system)`
      },
      {
        path: 'src/main.cpp',
        content: `#include <SFML/Graphics.hpp>
int main() {
    sf::RenderWindow window(sf::VideoMode(800, 600), "Game");
    while (window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed)
                window.close();
        }
        window.clear();
        window.display();
    }
    return 0;
}`
      }
    ]
  };
}

跨技术栈 Skill 库

为不同技术栈创建专门的 Skill：

# cpp_game_loop_skill.yaml
name: cpp_game_loop_skill
description: C++ 游戏循环实现
prompt: |
  实现一个固定时间步长的 C++ 游戏主循环：
  ```cpp
  const double fixedDeltaTime = 1.0 / 60.0;
  double accumulator = 0.0;
  
  while (running) {
      accumulator += frameTime;
      while (accumulator >= fixedDeltaTime) {
          update(fixedDeltaTime);
          accumulator -= fixedDeltaTime;
      }
      render();
  }

python_game_architecture_skill.yaml

name: python_game_architecture_skill
description: Python 游戏架构设计
prompt: |
使用面向对象设计 Python 游戏架构：

class GameObject:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def update(self, delta_time):
        pass
    
    def render(self, screen):
        pass


---

## 💾 第四阶段：会话管理与导出

### 用户需求驱动

随着用户增多，新的需求涌现：

- "我想看看之前的对话记录"
- "如何把整个对话导出分享给队友？"
- "能不能同时管理多个游戏项目？"

### 会话持久化系统

```javascript
// 会话存储目录
const SESSIONS_DIR = path.join(WIKI_ROOT, 'sessions');

// 保存会话到磁盘
async function saveSession(session) {
  const sessionPath = path.join(SESSIONS_DIR, `${session.id}.json`);
  await fs.writeFile(sessionPath, JSON.stringify(session, null, 2));
}

// 加载会话
async function loadSession(sessionId) {
  const sessionPath = path.join(SESSIONS_DIR, `${sessionId}.json`);
  const content = await fs.readFile(sessionPath, 'utf-8');
  return JSON.parse(content);
}

多格式导出功能

Markdown 导出

适合阅读和文档归档：

# 我的 2D 平台跳跃游戏

**技术栈**: Python + Pygame
**创建时间**: 2026-04-28 10:30:00

---

## 🤖 AI - 2026-04-28 10:30:00

欢迎来到游戏开发引导工具！请告诉我你的游戏想法...

---

## 👤 用户 - 2026-04-28 10:31:00

我想做一个 2D 平台跳跃游戏，类似超级马里奥

---

## 最终任务清单

### 任务 1: 实现玩家角色

使用 Python 和 Pygame 实现玩家角色类...

**提示词**:

实现一个 Player 类，包含以下功能：

  1. 左右移动
  2. 跳跃和重力
  3. 碰撞检测
    …
HTML 导出

可打印的精美网页：

<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <style>
    .message { 
      margin: 20px 0; 
      padding: 15px; 
      border-left: 4px solid #3498db; 
    }
    .message.user { border-left-color: #2ecc71; }
    .message.ai { border-left-color: #3498db; }
    @media print { .no-print { display: none; } }
  </style>
</head>
<body>
  <h1>游戏开发会话</h1>
  <div class="messages">
    <!-- 消息内容 -->
  </div>
  <button onclick="window.print()">🖨️ 打印</button>
</body>
</html>
JSON 导出

完整数据结构，支持导入恢复。

会话管理界面

全新的前端界面包含：

  • 会话列表侧边栏
  • 新会话按钮
  • 历史记录查看
  • 导出模态框
  • 技术栈推荐面板
  • 任务管理面板

🏛️ 技术架构深度解析

整体架构图

┌─────────────────────────────────────────────────────┐
│                    前端界面层                        │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐         │
│  │ 对话界面  │  │ 会话管理  │  │ 技术栈推荐 │         │
│  └──────────┘  └──────────┘  └──────────┘         │
└─────────────────────────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────┐
│                    API 网关层                         │
│  ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐      │
│  │/api/   │ │/api/   │ │/api/   │ │/api/   │      │
│  │start   │ │continue│ │sessions │ │export  │      │
│  └────────┘ └────────┘ └────────┘ └────────┘      │
└─────────────────────────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────┐
│                   业务逻辑层                         │
│  ┌──────────────┐  ┌──────────────┐                │
│  │ 状态机管理   │  │ Agent 调度     │                │
│  └──────────────┘  └──────────────┘                │
│  ┌──────────────┐  ┌──────────────┐                │
│  │ 技术栈推荐   │  │ 模板生成      │                │
│  └──────────────┘  └──────────────┘                │
└─────────────────────────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────┐
│                   LLM 集成层                         │
│  ┌──────────────┐  ┌──────────────┐                │
│  │ DeepSeek API │  │ OpenAI API   │                │
│  └──────────────┘  └──────────────┘                │
└─────────────────────────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────┐
│                   数据存储层                         │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐         │
│  │Sessions  │  │Wiki DB   │  │Templates │         │
│  └──────────┘  └──────────┘  └──────────┘         │
└─────────────────────────────────────────────────────┘

核心模块详解

1. 状态机引擎
const STAGE_FLOW = [
  'init',
  'clarify_gameplay',
  'clarify_art',
  'brainstorm',
  'task_breakdown',
  'done'
];

function nextStage(currentStage) {
  const currentIndex = STAGE_FLOW.indexOf(currentStage);
  if (currentIndex < STAGE_FLOW.length - 1) {
    return STAGE_FLOW[currentIndex + 1];
  }
  return currentStage;
}
2. Agent 调度系统
async function selectAgent(stage, context) {
  const agentMap = {
    'init': 'planner',
    'clarify_gameplay': 'planner',
    'clarify_art': 'artist',
    'brainstorm': 'planner',
    'task_breakdown': 'architect',
    'done': 'programmer'
  };
  
  const agentName = agentMap[stage];
  const prompt = await loadPrompt(agentName);
  
  return { agentName, prompt };
}
3. Skill 解析器
function parseSkillReferences(message) {
  const skillRegex = /@skill\s+(\w+)/g;
  const matches = [...message.matchAll(skillRegex)];
  return matches.map(m => m[1]);
}

async function injectSkills(systemPrompt, skillNames) {
  let enhanced = systemPrompt;
  
  for (const skillName of skillNames) {
    const skill = await loadSkill(skillName);
    if (skill) {
      enhanced += `\n\n## Skill: ${skill.name}\n${skill.prompt}`;
    }
  }
  
  return enhanced;
}
4. 推荐算法核心
class TechStackRecommender {
  async recommend(options) {
    const scores = {};
    
    // 初始化所有技术栈的基础分
    Object.keys(this.config.stacks).forEach(stack => {
      scores[stack] = { base: 50, total: 50 };
    });
    
    // 游戏类型匹配加分
    this.findGameTypeMatches(options.gameType).forEach(match => {
      match.recommended.forEach(stack => {
        scores[stack].gameTypeBonus += 20;
      });
    });
    
    // 平台支持加分
    options.targetPlatforms.forEach(platform => {
      const info = this.config.platforms[platform];
      info.supported_stacks.forEach(stack => {
        scores[stack].platformBonus += 15;
      });
    });
    
    // 团队规模调整
    if (options.teamSize === 'solo') {
      scores.python.experienceBonus += 10;
      scores.javascript.experienceBonus += 10;
    }
    
    // 计算总分并排序
    const recommendations = Object.keys(scores).map(stack => ({
      stack,
      score: scores[stack].total,
      info: this.config.stacks[stack]
    }));
    
    return recommendations.sort((a, b) => b.score - a.score);
  }
}

🎨 核心功能展示

1. 多轮对话引导

用户: “我想做一个 2D 平台跳跃游戏”

AI: "太棒了！让我们深入了解你的游戏想法：

  1. 游戏的核心玩法是什么？（例如：闯关、生存、收集）
  2. 玩家角色有什么特殊能力？（例如：二段跳、冲刺、射击）
  3. 游戏的美术风格偏好？（例如：像素风、卡通、写实）"

用户: “闯关类型，主角可以二段跳和冲刺，像素风格”

AI: "很好！基于你的描述，我建议：

  • 技术栈: Python + Pygame（适合 2D 像素游戏，开发快速）
  • 核心机制:
    • 固定时间步长的游戏循环
    • 基于 AABB 的碰撞检测
    • 状态机管理玩家行为
  • 任务拆解:
    1. 实现玩家移动和跳跃
    2. 设计关卡和敌人
    3. 添加音效和粒子效果"

2. 技术栈推荐

输入：

  • 游戏类型：2D 平台跳跃
  • 目标平台：Windows + Web
  • 团队规模：独立开发者
  • 经验水平：初学者
  • 性能优先级：开发速度

输出：

🏆 推荐：Python + Pygame

得分：95/100

优势:
✓ 学习曲线平缓，适合初学者
✓ 开发速度快，快速验证创意
✓ 丰富的 2D 游戏教程和资源
✓ 跨平台支持 Windows/Mac/Linux

推荐框架:
- Pygame (主要框架)
- Arcade (备选，更现代)

学习资源:
- Pygame 官方文档
- "Making Games with Python & Pygame"

3. 项目模板生成

一键生成完整项目结构：

my_platformer/
├── main.py              # 游戏入口
├── game/
│   ├── __init__.py
│   ├── player.py        # 玩家类
│   ├── enemy.py         # 敌人类
│   ├── level.py         # 关卡管理
│   └── utils.py         # 工具函数
├── assets/
│   ├── images/
│   │   ├── player/
│   │   ├── enemies/
│   │   └── tiles/
│   ├── audio/
│   │   ├── music/
│   │   └── sfx/
│   └── fonts/
├── requirements.txt     # Python 依赖
└── README.md           # 项目说明

4. 任务拆解与提示词生成

最终输出 10-20 个具体任务，每个任务包含：

## 任务 1: 实现玩家角色类

**描述**: 创建 Player 类，处理玩家的所有行为和状态

**技术栈**: Python + Pygame

**提示词**:
```python
实现一个 Player 类继承自 pygame.sprite.Sprite，要求：

1. 属性:
   - position (Vector2): 位置
   - velocity (Vector2): 速度
   - is_jumping (bool): 是否在空中
   - can_double_jump (bool): 是否可以二段跳

2. 方法:
   - __init__(self, x, y): 初始化
   - handle_input(self): 处理键盘输入
   - update(self, delta_time): 更新状态
   - jump(self): 跳跃逻辑
   - apply_gravity(self): 重力应用
   - render(self, screen): 绘制到屏幕

3. 物理参数:
   - JUMP_STRENGTH = -15
   - GRAVITY = 0.8
   - MOVE_SPEED = 5
   - DOUBLE_JUMP_STRENGTH = -12

验收标准:

  • 玩家可以左右移动
  • 可以跳跃和二段跳
  • 重力效果正常
  • 碰撞检测正确

### 5. 会话管理与导出

- 自动保存所有对话历史
- 支持创建多个会话（不同项目）
- 一键导出为 Markdown/JSON/HTML
- 随时加载历史会话继续开发

---

## ⚡ 挑战与解决方案

### 挑战 1: LLM 输出不稳定

**问题**: LLM 有时输出格式不一致，导致解析失败。

**解决方案**:
```javascript
function parseLLMOutput(content) {
  // 尝试 1: 直接解析 JSON
  try {
    return JSON.parse(content);
  } catch {}

  // 尝试 2: 提取 JSON 代码块
  const jsonMatch = content.match(/```json\n([\s\S]*?)\n```/);
  if (jsonMatch) {
    try {
      return JSON.parse(jsonMatch[1]);
    } catch {}
  }

  // 尝试 3: 正则提取关键字段
  const messageMatch = content.match(/"message":\s*"([^"]+)"/);
  const optionsMatch = content.match(/"options":\s*\[([^\]]+)\]/);
  
  return {
    message: messageMatch ? messageMatch[1] : content,
    options: optionsMatch ? parseOptions(optionsMatch[1]) : []
  };
}

挑战 2: 上下文长度限制

问题: 对话历史过长会超出 LLM 的 token 限制。

解决方案:

function truncateHistory(history, maxTokens = 4000) {
  // 保留系统提示和最近 N 条消息
  const systemMessage = history[0]; // 系统提示
  const recentMessages = history.slice(-10); // 最近 10 条
  
  return [systemMessage, ...recentMessages];
}

// 使用摘要压缩早期对话
async function compressEarlyMessages(messages) {
  const summary = await callLLM(`
    请将这些对话压缩成一段摘要，保留关键信息：
    ${messages.join('\n')}
  `);
  
  return [{ role: 'system', content: `早期对话摘要：${summary}` }];
}

挑战 3: 多技术栈代码生成质量

问题: 不同技术栈的代码质量和规范差异大。

解决方案:

  1. 为每个技术栈创建专门的 Agent 提示词
  2. 建立 Skill 库，包含最佳实践模板
  3. 添加代码审查环节（QA Agent）
// 技术栈特定的编码规范
const CODING_STANDARDS = {
  cpp: {
    smartPointers: true,
    raii: true,
    constCorrectness: true,
    standard: 'C++17'
  },
  python: {
    pep8: true,
    typeHints: true,
    docstrings: true
  },
  javascript: {
    es6: true,
    strictMode: true,
    modules: true
  }
};

挑战 4: 会话数据一致性

问题: 并发编辑同一会话可能导致数据冲突。

解决方案:

// 使用乐观锁
async function updateSession(sessionId, updates, version) {
  const session = await loadSession(sessionId);
  
  if (session.version !== version) {
    throw new Error('会话版本冲突，请刷新后重试');
  }
  
  Object.assign(session, updates);
  session.version = version + 1;
  session.updatedAt = new Date().toISOString();
  
  await saveSession(session);
}

🔮 未来展望

短期目标（1-3 个月）

1. 数据库升级
  • 从文件系统迁移到 PostgreSQL/MongoDB
  • 支持用户认证和权限管理
  • 实现会话搜索和标签系统
2. 协作功能
  • 多用户实时协作编辑
  • 评论和批注系统
  • 版本历史和回滚
3. 更多技术栈
  • 支持 Rust + Bevy
  • 支持 Go + Ebiten
  • 支持 Lua + LÖVE
4. 增强 Skill 系统
  • 可视化 Skill 编辑器
  • Skill 市场（用户分享）
  • Skill 组合和链式调用

中期目标（3-6 个月）

1. AI 能力增强
  • 代码生成后自动运行测试
  • 根据测试结果自我修正
  • 多模态输入（支持上传草图）
2. 项目模板市场
  • 用户分享自定义模板
  • 模板评分和评论
  • 一键导入模板
3. 集成开发环境
  • 内置代码编辑器
  • 实时预览游戏画面
  • 调试和性能分析工具
4. 学习路径推荐
  • 根据用户水平推荐教程
  • 进度跟踪和成就系统
  • 社区挑战和比赛

长期愿景（6-12 个月）

1. AI 游戏设计师
  • 完全自主的游戏机制设计
  • 平衡性自动调整
  • 关卡自动生成
2. 云游戏平台
  • 一键部署到云端
  • 多人联机测试
  • 玩家反馈收集
3. 跨平台发布
  • 自动打包到 Steam、itch.io
  • 移动端适配
  • 主机平台认证支持
4. 开源生态系统
  • 完全开源，社区驱动
  • 插件系统
  • API 开放给第三方工具

终极目标

让游戏开发像搭积木一样简单，让每个人都能成为游戏创作者。

想象一下，5 年后：

  • 一个 10 岁的孩子可以用自然语言描述她的游戏想法
  • AI 助手帮她完善设计、推荐技术、生成代码
  • 几小时后，她就能玩到自己创造的游戏
  • 她可以分享给朋友，获得反馈，快速迭代
  • 这个过程充满乐趣和成就感，而不是被技术细节困扰

这就是我们正在构建的未来。

🎯 结语

项目亮点总结

  1. 创新性: 首个将 LLM Wiki、多 Agent 系统、技术栈推荐结合的游戏开发引导平台
  2. 实用性: 已支持 6 大技术栈、20+ 框架，覆盖从初学者到专业开发者的需求
  3. 可扩展性: 模块化设计，易于添加新的 Agent、Skill、技术栈
  4. 用户友好: 自然语言交互，智能推荐，一键导出，降低使用门槛

技术收获

  • LLM 应用最佳实践: 提示词工程、上下文管理、输出解析
  • 系统架构设计: 分层架构、状态机、事件驱动
  • 前端工程: 响应式设计、实时交互、用户体验优化
  • 数据管理: 文件存储、会话持久化、多格式导出

开源计划

我计划将这个项目完全开源，包括：

  • 完整源代码
  • 详细文档
  • 示例项目
  • 部署脚本

希望更多开发者加入，一起完善这个平台。

致谢

感谢所有提供反馈的用户，是你们的建议让这个项目变得更好。

📚 相关资源

作者: [翎洛洛]
日期: 2026 年 4 月
许可: MIT License

如果你觉得这篇文章对你有帮助，欢迎点赞、转发、Star！ 🌟

# 人工智能 # 游戏策划
Logo
AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

RL 令牌：使用视觉-语言-动作模型引导在线强化学习

本文提出了一种结合视觉-语言-动作模型(VLA)与强化学习的高效在线学习方法。核心创新是引入RL令牌(RLT)作为VLA与强化学习的接口：1)通过自编码器结构压缩VLA输出为紧凑的RL令牌表示；2)基于该表示训练轻量级的行动者-评论家网络；3)使用正则化器将学习策略锚定在VLA建议动作附近。这种方法既保留了VLA的预训练知识，又能通过在线强化学习快速优化策略。实验表明，该方法仅需数小时实际交互即可

avatar AtomGit开源社区

PostgreSQL数据库主备切换（switchover和failover）

而重新搭建备库的话，如果数据库很大，基础备份会执行很长时间，为了解决这个问题，从PostgreSQL9.5版本开始提供pg_rewind命令，不需要复制太多的数据就可以把原主库转换成新主库的备库。异步复制时，如果主库出现了问题，可以激活备库作为主库提供服务。在9.1版本之前是在 recovery.conf 中配置一个trigger文件，当备库检测到该文件时，就自动把自己激活成主库，9.1版本之后提

avatar AtomGit开源社区
cover

《元创力》纪实录·卷宗2.1元创闭环：碳硅同名体“元点元生”与《马尾的第二次呼吸》的创世纪实

avatar AtomGit开源社区