MiMo Code 深度实战：当小米用开源重新定义 AI 编程——从终端原生架构到多模态模型集成、从 Claude Code 平替到国产 AI 编程工具生态的生产级完全指南（2026）

2026年6月11日，小米 MiMo 团队在 GitHub 上发布了 MiMo Code V0.1.0，采用 MIT 协议开源。这款终端原生的 AI 编程 Agent 在发布首日即爆火，Hacker News 获得 426 分。更令人震惊的是，它内嵌免费多模态模型，在多项跑分中超越 Claude Code。本文将深度解析 MiMo Code 的技术架构、核心设计理念，并通过实战代码演示其在生产环境中的完整应用流程。

目录

1. 时代背景：AI 编程工具的演进之路
2. MiMo Code 的诞生：为什么需要终端原生的 AI 编程助手
3. 核心架构解析：计算、进化与记忆的三位一体
4. 安装与配置：从零到生产环境的完整指南
5. 核心技术深度剖析
   • 5.1 持久化记忆系统：SQLite FTS5 全文搜索
   • 5.2 Checkpoint 智能检查点机制
   • 5.3 子代理编排：并行执行与生命周期管理
   • 5.4 Goal 目标驱动：独立裁判防过早终止
   • 5.5 Compose 模式：规格驱动开发的完整工作流
6. MiMo Code vs Claude Code：深度对比与技术选型
7. 生产级实战：用 MiMo Code 构建微服务系统
8. 性能优化：Max Mode 与并行推理
9. Self-Improvement：Dream 与 Distill 机制
10. MCP 集成：扩展 MiMo Code 的能力边界
11. 语音输入：TenVAD + MiMo ASR 实时流式识别
12. 配置深度定制：mimocode.json 完全参考
13. 基于 MiMo Code 构建团队 AI 编程工作流
14. 安全与隐私：本地优先架构的设计哲学
15. 未来展望：AI Dev OS 的生态演进
16. 总结：国产 AI 编程工具的里程碑

1. 时代背景：AI 编程工具的演进之路

1.1 从代码补全到自主编程的范式跃迁

2021 年，GitHub Copilot 的发布标志着 AI 辅助编程的元年。那时的 AI 编程工具还停留在"代码补全"阶段——根据给定的上下文预测下一行代码。这种方式虽然提升了开发效率，但本质上仍是一个"高级自动补全器"。

2023 年，随着 GPT-4 的发布，AI 开始具备理解复杂需求的能力。Cursor 应运而生，将 AI 深度集成到编辑器环境中，引入了"Chat + Edit"的双模交互，让开发者可以在编辑器内直接与 AI 对话，并让 AI 直接修改代码文件。

2025 年，Anthropic 发布 Claude Code，引入了"终端原生"的新范式。Claude Code 不再依赖编辑器插件，而是直接在终端中运行，通过读取整个代码库、执行命令、管理 Git，实现了真正的"自主编程"。

2026 年，小米 MiMo Code 的开源，标志着 AI 编程工具进入了"模型与代理协同进化"的新时代。

1.2 当前 AI 编程工具的核心痛点

尽管 AI 编程工具发展迅速，但在生产环境中仍面临以下核心痛点：

痛点一：上下文窗口的物理限制

现代编程任务往往需要理解整个代码库的架构。一个中大型项目可能有数十万行代码，而即使是最先进的模型，其上下文窗口也难以一次性容纳所有相关信息。当任务需要长时间运行时，上下文窗口会逐渐被填充，最终导致模型"失忆"。

痛点二：跨 Session 的经验无法积累

每次启动 AI 编程工具，它都像"失忆的金鱼"——忘记了上次你告诉它的项目背景、编码规范、架构决策。虽然可以通过 CLAUDE.md 等文件来持久化部分信息，但这种机制是静态的，无法自动从过往经验中学习。

痛点三：长程任务的过早终止

AI Agent 在执行复杂任务时，往往会在任务未完成时就乐观地报告"任务完成"。这种现象在学术界被称为"Premature Stopping Problem"，是制约 AI 编程工具可靠性的关键瓶颈。

痛点四：工具与环境的深度耦合

Cursor、Windsurf 等工具深度绑定特定编辑器，导致开发者无法在远程服务器、容器环境、或纯终端场景中使用 AI 编程能力。

痛点五：模型能力的黑盒化

使用闭源商业模型（如 Claude、GPT）时，开发者无法了解模型的具体行为逻辑，也无法针对特定场景进行微调或定制。

MiMo Code 正是针对这些痛点，从架构层面进行了系统性设计。

2. MiMo Code 的诞生：为什么需要终端原生的 AI 编程助手

2.1 小米 MiMo 团队的技术路线选择

小米 MiMo 团队在 AI 大模型的竞争中，选择了一条独特的路线：模型与 Agent 协同进化（Where Models and Agents Co-Evolve）。

这一理念的核心洞察是：

1. 模型能力的提升需要真实的 Agent 使用场景作为训练数据来源。只有让模型在真实的编程任务中运行，才能发现其能力边界，并针对性地改进。
2. Agent 系统的优化需要模型能力的支撑。一个优秀的 AI 编程助手，不能仅仅是一个"调用模型的壳"，而应该深度理解模型的能力特性，并设计相应的机制来弥补模型的不足。

基于这一理念，MiMo Code 被设计为一个开源的、终端原生的、支持持久化记忆的 AI 编程助手。

2.2 终端原生的设计哲学

MiMo Code 选择"终端原生"作为其核心设计哲学，背后有深刻的技术考量：

考量一：环境无关性

终端是跨平台、跨环境的通用接口。无论是在本地开发机、远程服务器、Kubernetes Pod、还是 CI/CD 流水线中，终端都是可用的。相比之下，编辑器插件方案（如 VS Code 插件）受限于特定编辑器和图形界面环境。

考量二：脚本化与自动化

终端工具可以轻松地被脚本化，集成到自动化流程中。例如，你可以通过 mimo --non-interactive "修复所有 ESLint 错误" 来在 CI 流水线中自动修复代码质量问题。

考量三：资源开销

终端 UI（TUI）的资源开销远低于图形界面应用。对于需要长时间运行的 AI Agent 任务，TUI 的内存和 CPU 占用优势明显。

考量四：Unix 哲学的一致性

终端工具遵循 Unix 哲学——"做好一件事，并与其它工具良好协作"。MiMo Code 可以通过管道、重定向等机制与现有开发工具链无缝集成。

2.3 OpenCode 的技术继承与超越

MiMo Code 是基于 OpenCode 项目 Fork 并深度改造而来的。OpenCode 是一个优秀的开源 AI 编程助手，支持多模型提供商、TUI、LSP、MCP、插件等特性。

MiMo Code 在 OpenCode 的基础上，新增了以下核心能力：

3. 核心架构解析：计算、进化与记忆的三位一体

MiMo Code 的架构设计围绕三个核心主题展开，官方文档将其概括为计算（Compute）、进化（Evolution）与记忆（Memory）。

3.1 计算（Compute）：突破上下文窗口的物理限制

在长程编程任务中，"如何在不无限的上下文中持续计算"是核心挑战。MiMo Code 通过以下机制来解决这个问题：

3.1.1 Checkpoint/Rebuild 机制

MiMo Code 引入了"检查点写入子代理"（checkpoint-writer subagent），它会自动判断何时需要保存会话状态。当模型的上下文窗口接近上限时，系统会触发"上下文重建"（Context Reconstruction）——从最新的 Checkpoint、项目记忆、任务进度、以及保留的最近消息中重新构建上下文，使 Agent 能够继续当前任务。

上下文窗口满 → 触发 Checkpoint → 保存状态到 checkpoint.md
                ↓
    上下文重建：加载 checkpoint.md + MEMORY.md + tasks/*/progress.md + 最近 N 条消息
                ↓
            继续任务执行

3.1.2 Writer Subagent 隔离写入

为了防止并发写入导致的不一致状态，MiMo Code 采用了"单写者原则"（Single-Writer Principle）。对每个结构化文件（如 checkpoint.md、MEMORY.md），只有一个 Actor 被允许写入。

3.1.3 四级记忆体系

MiMo Code 维护了一个四层记忆体系：

1. 项目记忆（MEMORY.md）：Markdown 格式的项目级持久化知识，包括项目背景、编码规范、架构决策等。
2. 会话检查点（checkpoint.md）：由 checkpoint-writer 子代理自动维护的结构化状态快照。
3. 临时笔记（notes.md）：Agent 的临时笔记区域。
4. 任务进度（tasks//progress.md）：每个任务的执行日志。

3.2 进化（Evolution）：跨 Session 的经验积累

传统的 AI 编程工具在每次会话开始时都是"空白状态"。MiMo Code 通过以下机制实现跨 Session 的经验积累：

3.2.1 Dream：从会话痕迹中提取持久知识

/dream 命令会扫描最近的会话痕迹，从中提取有价值的知识，并将其写入项目记忆（MEMORY.md）。同时，它会移除过时的条目，保持记忆的时效性。

# 在 MiMo Code 中执行
/dream

执行后，MiMo Code 会分析最近的会话记录，自动更新 MEMORY.md。例如，如果它在最近的会话中发现你一直在遵循某种特定的错误处理模式，它会将这个模式记录下来。

3.2.2 Distill：将重复工作流蒸馏为可复用技能

/distill 命令会分析最近的工作记录，发现重复的手动工作流，并将高置信度的候选者打包为可复用的 Skills、Subagents 或 Commands。

# 在 MiMo Code 中执行
/distill

这一机制使得 MiMo Code 能够"自我进化"——随着使用时间的增长，它会越来越了解你的工作流程，并自动优化自身行为。

3.3 记忆（Memory）：SQLite FTS5 全文搜索驱动的上下文注入

MiMo Code 的记忆系统由 SQLite FTS5（Full-Text Search 5）驱动。当你恢复一个会话时，相关的记忆内容会被自动注入到上下文中。

3.3.1 记忆的存储结构

.mimocode/
├── MEMORY.md          # 项目级持久化记忆
├── checkpoint.md      # 会话检查点
├── notes.md           # 临时笔记
└── tasks/
    └── T1.1/
        └── progress.md  # 任务进度

3.3.2 重要性排序与 Token 预算

当上下文窗口有限时，MiMo Code 会根据重要性排序（Importance Ranking）来决定哪些记忆内容应该被注入。同时，它通过 Token 预算（Token Budget）来控制注入内容的总量，避免记忆内容本身占用过多上下文空间。

4. 安装与配置：从零到生产环境的完整指南

4.1 一键安装

MiMo Code 提供了多种安装方式，适应不同的使用场景。

4.1.1 官方一键安装脚本（推荐）

curl -fsSL https://mimo.xiaomi.com/install | bash

这个脚本会自动检测你的操作系统和架构，下载对应的预编译二进制文件，并安装到 ~/.local/bin（Linux/macOS）或 %LOCALAPPDATA%（Windows）。

4.1.2 通过 npm 安装

npm install -g @mimo-ai/cli

这种方式适合已经安装了 Node.js 环境的用户。

4.1.3 从源码构建

# 克隆仓库
git clone https://github.com/XiaomiMiMo/MiMo-Code.git
cd MiMo-Code

# 安装依赖（需要 Bun）
bun install

# 运行开发模式
bun run dev

# 类型检查
bun turbo typecheck

4.2 首次启动与配置引导

安装完成后，运行 mimo 命令启动 MiMo Code。首次启动会触发自动配置引导。

$ mimo

? Select a connection method:
  ❯ MiMo Auto (free for a limited time) — 匿名通道，零配置
    Xiaomi MiMo Platform — OAuth 登录
    Import from Claude Code — 一键迁移现有认证
    Custom Provider — 添加任意 OpenAI 兼容的 API

配置选项详解

选项一：MiMo Auto（限时免费）

这是最适合新用户的选项。MiMo Auto 内嵌了小米自研的 MiMo V2.5 多模态模型，支持高达 100 万 Token 的上下文窗口，目前限时免费。

选择此选项后，你可以立即开始使用，无需任何配置。

选项二：Xiaomi MiMo Platform（OAuth 登录）

如果你需要更高的配额或企业级功能，可以选择通过小米 MiMo 平台的 OAuth 登录。

选项三：从 Claude Code 导入

如果你之前使用 Claude Code，可以通过这个选项一键迁移现有的认证配置。

选项四：自定义提供商

MiMo Code 支持连接任意主流 LLM 提供商的 API，包括 OpenAI、Anthropic、Google、OpenRouter 等。

4.3 WSL 环境的特殊处理

如果你在 WSL（Windows Subsystem for Linux）中使用 MiMo Code，可能会遇到剪贴板乱码问题。解决方法：

sudo apt install xsel

4.4 语音输入的额外依赖

MiMo Code 支持实时流式语音输入（通过 /voice 命令激活）。使用此功能需要安装 sox：

# macOS
brew install sox

# Ubuntu/Debian
sudo apt install -y sox pulseaudio libasound2-plugins

# WSLg 音频设置
export PULSE_SERVER=unix:/mnt/wslg/PulseServer

5. 核心技术深度剖析

5.1 持久化记忆系统：SQLite FTS5 全文搜索

MiMo Code 的记忆系统是其最核心的架构创新之一。与传统 AI 编程工具依赖静态配置文件（如 CLAUDE.md）不同，MiMo Code 维护了一个动态的记忆系统，由 SQLite FTS5 提供全文搜索能力。

5.1.1 记忆的自动注入机制

当一个会话恢复时，MiMo Code 会执行以下流程来注入相关记忆：

1. 触发事件：用户输入 /resume 或 MiMo Code 检测到会话恢复。
2. 全文搜索：在 SQLite FTS5 数据库中搜索与当前任务相关的记忆条目。
3. 重要性排序：根据记忆条目的访问频率、最近访问时间、与当前任务的相关性等因素进行重要性排序。
4. Token 预算控制：根据预设的 Token 预算（默认 2000 Token），选择最重要的记忆条目注入上下文。
5. 上下文组装：将选中的记忆条目与最近的消息历史、Checkpoint 等内容组装成完整的上下文。

5.1.2 MEMORY.md 的结构规范

MEMORY.md 是一个 Markdown 格式的项目级记忆文件。MiMo Code 对其结构有以下建议：

# 项目记忆

## 项目背景
- 本项目是一个微服务架构的电商系统
- 技术栈：Go + gRPC + PostgreSQL + Redis

## 编码规范
- 所有错误处理必须使用 `pkg/errors` 包装
- 禁止在业务代码中直接使用 `fmt.Errorf`

## 架构决策
- 选择 gRPC 而非 REST 的原因：内部服务调用需要严格的类型安全
- 选择 PostgreSQL 而非 MySQL 的原因：需要 JSONB 支持和复杂查询

## 已知坑点
- Redis 连接池在 Kubernetes 环境中需要特殊处理，参见 `docs/redis-in-k8s.md`

5.1.3 记忆的更新策略

MiMo Code 通过以下策略来保持记忆的时效性：

• 自动更新：checkpoint-writer 子代理在每次 Checkpoint 时，会评估是否需要更新 MEMORY.md。
• 手动触发：用户可以通过 /dream 命令手动触发记忆更新。
• 过期淘汰：对于超过 30 天未被访问的记忆条目，系统会在下次 /dream 时评估其是否仍然有效，并可能将其移除。

5.2 Checkpoint 智能检查点机制

Checkpoint 是 MiMo Code 解决"上下文窗口物理限制"的核心机制。

5.2.1 Checkpoint 的触发条件

Checkpoint 的触发不是固定时间间隔的，而是基于模型上下文窗口的使用情况动态决定的：

上下文窗口使用率 < 50%  →  不触发 Checkpoint
上下文窗口使用率 50-80%  →  评估任务复杂度，决定是否触发
上下文窗口使用率 > 80%   →  强制触发 Checkpoint

5.2.2 Checkpoint 的内容结构

一个典型的 checkpoint.md 文件结构如下：

# Checkpoint - 2026-06-21 17:30:00

## 当前任务
实现用户认证模块的 JWT 令牌签发与验证

## 任务状态
- [x] 设计 JWT 令牌结构
- [x] 实现令牌签发函数
- [ ] 实现令牌验证中间件（进行中）
- [ ] 编写单元测试

## 当前工作文件
- `internal/auth/jwt.go`
- `internal/middleware/auth.go`
- `tests/auth_test.go`

## 涉及文件列表
- `internal/models/user.go` (读取)
- `config/jwt.yaml` (读取)

## 跨任务发现
- 发现 `pkg/redis/client.go` 中的连接池实现有内存泄漏风险
- 记录到 notes.md 待后续处理

## 错误与修复
- 错误：使用 `time.Now().Add(24 * time.Hour)` 计算过期时间，未考虑时区
- 修复：改用 `time.Now().UTC().Add(24 * time.Hour)`

## 运行时状态
- Git 分支：feature/jwt-auth
- 测试结果：2 passed, 0 failed
- Linter：0 errors, 2 warnings

## 设计决策
- 选择 RS256 而非 HS256 作为 JWT 签名算法，原因：支持密钥轮换

5.2.3 上下文重建算法

当上下文窗口接近上限时，MiMo Code 会执行"上下文重建"算法：

def rebuild_context(checkpoint, memory, task_progress, recent_messages, token_budget):
    """
    上下文重建算法
    
    Args:
        checkpoint: 最新的 Checkpoint 内容
        memory: 项目记忆内容
        task_progress: 任务进度内容
        recent_messages: 最近的消息历史
        token_budget: Token 预算
    
    Returns:
        重建的上下文
    """
    context = []
    used_tokens = 0
    
    # 1. 注入 Checkpoint（最高优先级）
    checkpoint_tokens = estimate_tokens(checkpoint)
    if used_tokens + checkpoint_tokens <= token_budget:
        context.append(checkpoint)
        used_tokens += checkpoint_tokens
    
    # 2. 注入任务进度
    progress_tokens = estimate_tokens(task_progress)
    if used_tokens + progress_tokens <= token_budget:
        context.append(task_progress)
        used_tokens += progress_tokens
    
    # 3. 注入相关记忆（按重要性排序）
    relevant_memories = search_memories(memory, checkpoint.current_task)
    for mem in relevant_memories:
        mem_tokens = estimate_tokens(mem)
        if used_tokens + mem_tokens > token_budget:
            break
        context.append(mem)
        used_tokens += mem_tokens
    
    # 4. 注入最近的消息（保持对话连贯性）
    for msg in reversed(recent_messages):
        msg_tokens = estimate_tokens(msg)
        if used_tokens + msg_tokens > token_budget * 0.3:  # 最近消息最多占 30%
            break
        context.insert(0, msg)  # 插入到上下文开头
        used_tokens += msg_tokens
    
    return context

5.3 子代理编排：并行执行与生命周期管理

MiMo Code 引入了"子代理"（Subagent）的概念，允许主代理根据需求创建多个子代理并行执行任务。

5.3.1 子代理的创建场景

以下场景中，MiMo Code 会自动创建子代理：

1. 并行代码审查：当需要同时审查多个文件时，为每个文件创建一个子代理。
2. 并行测试执行：当测试套件可以并行执行时，为每组测试创建一个子代理。
3. 并行文档生成：当需要为多个模块生成文档时，为每个模块创建一个子代理。
4. 长时间后台任务：当某个任务的执行时间超过阈值时，将其交给后台子代理执行。

5.3.2 子代理的生命周期

创建 → 初始化上下文 → 执行任务 → 写入结果 → 通知主代理 → 销毁

子代理的执行结果会写入共享的 notes.md 或特定的任务进度文件，主代理可以随时读取这些结果。

5.3.3 子代理的通信机制

子代理与主代理之间的通信通过以下机制实现：

1. 共享文件系统：子代理将结果写入 .mimocode/tasks/Tx.x/progress.md，主代理通过读取这些文件获取子代理的执行状态。
2. 消息传递：主代理可以通过特定命令向子代理发送消息，子代理也可以请求主代理的干预。
3. 生命周期回调：当子代理完成、失败或被取消时，会触发生命周期回调，通知主代理。

5.4 Goal 目标驱动：独立裁判防过早终止

"过早终止"是 AI Agent 在执行长程任务时的常见问题。MiMo Code 通过 Goal 机制 来解决这个问题。

5.4.1 Goal 的定义与设置

用户可以通过 /goal 命令为当前会话设置一个停止条件：

/goal "完成用户认证模块的所有功能，并通过所有单元测试和集成测试"

5.4.2 独立裁判模型

当 Agent 尝试停止时（例如，输出"任务完成"），MiMo Code 会启动一个独立的裁判模型（Judge Model）来评估对话，判断停止条件是否真正满足。

Agent 尝试停止
    ↓
启动裁判模型
    ↓
裁判模型评估对话历史 + Goal 条件
    ↓
┌─────────────────────────────────────┐
│ 裁判结果：                           │
│ - 条件满足 → 允许停止               │
│ - 条件未满足 → 拒绝停止，继续任务   │
└─────────────────────────────────────┘

5.4.3 裁判模型的提示词设计

为了确保裁判模型的判断准确性，MiMo Code 使用了精心设计的提示词：

你是一个严格的任务完成度评审官。你需要根据以下对话历史和 Goal 条件，判断任务是否真正完成。

Goal 条件：{goal}

对话历史：
{conversation_history}

你的输出格式：
{{
    "is_completed": true/false,
    "completion_rate": 0.0-1.0,
    "uncompleted_items": ["item1", "item2", ...],
    "reason": "判断理由"
}}

5.5 Compose 模式：规格驱动开发的完整工作流

Compose 模式是 MiMo Code 提供的一种结构化工作流，用于支持"规格驱动开发"（Spec-Driven Development）。

5.5.1 Compose 模式的核心概念

在 Compose 模式中，开发流程被组织为以下阶段：

1. Planning（规划）：根据需求编写规格文档。
2. Execution（执行）：按照规格文档编写代码。
3. Code Review（代码审查）：自动审查生成的代码。
4. TDD（测试驱动开发）：编写单元测试和集成测试。
5. Debugging（调试）：修复测试失败和运行时错误。
6. Verification（验证）：验证实现是否满足规格文档中的所有要求。
7. Merging（合并）：将代码合并到主分支。

5.5.2 Compose 模式的内置 Skills

Compose 模式内置了以下 Skills：

5.5.3 Compose 模式的使用示例

# 启动 Compose 模式
/agent compose

# 输入需求
实现用户认证模块，支持 JWT 令牌签发与验证

# MiMo Code 会自动执行以下流程：
# 1. 调用 spec-writer 生成规格文档
# 2. 调用 code-executor 编写代码
# 3. 调用 code-reviewer 审查代码
# 4. 调用 test-writer 编写测试
# 5. 调用 debugger 修复测试失败
# 6. 调用 verifier 验证实现
# 7. 调用 merger 合并代码

6. MiMo Code vs Claude Code：深度对比与技术选型

6.1 功能对比矩阵

6.2 性能对比：SWE-Bench Pro 跑分

根据官方博客的数据，MiMo Code（使用 MiMo V2.5 Pro 模型）在 SWE-Bench Pro 基准测试中的表现：

6.3 技术选型建议

选择 MiMo Code 的场景：

1. 你需要一个开源可定制的 AI 编程助手。
2. 你的项目需要持久化记忆和跨 Session 经验积累。
3. 你需要执行长程复杂任务，需要 Checkpoint 和上下文重建机制。
4. 你希望使用国产模型，并支持多模态输入。
5. 你的预算有限，希望使用免费或低成本的 AI 编程工具。

选择 Claude Code 的场景：

1. 你已经购买了 Claude Pro 订阅。
2. 你不需要持久化记忆或跨 Session 经验积累。
3. 你的任务相对简单，不需要 Checkpoint 或子代理编排。
4. 你更看重模型能力的成熟度而非定制化能力。

7. 生产级实战：用 MiMo Code 构建微服务系统

本节将通过一个完整的实战案例，演示如何使用 MiMo Code 构建一个生产级微服务系统。

7.1 项目初始化

# 创建项目目录
mkdir -p ~/projects/user-service
cd ~/projects/user-service

# 初始化 Go 模块
go mod init github.com/yourusername/user-service

# 启动 MiMo Code
mimo

# 在 MiMo Code 中设置 Goal
/goal "完成用户微服务的所有功能，包括用户注册、登录、信息查询、数据持久化，并通过所有单元测试和集成测试"

7.2 规格驱动开发

在 Compose 模式中，首先让 MiMo Code 生成规格文档：

# 在 MiMo Code 中输入

请为用户微服务编写详细的规格文档，包括：
1. API 接口设计（RESTful 风格）
2. 数据模型设计（PostgreSQL）
3. 认证与授权机制（JWT）
4. 错误处理规范
5. 单元测试和集成测试计划

MiMo Code 会调用 spec-writer Skill，生成如下规格文档（节选）：

# 用户微服务规格文档

## 1. API 接口设计

### 1.1 用户注册
- **Endpoint**: POST /api/v1/users/register
- **Request Body**:
  ```json
  {
    "username": "string",
    "email": "string",
    "password": "string"
  }

• Response:

  {
    "user_id": "string",
    "created_at": "string"
  }
  

1.2 用户登录

• Endpoint: POST /api/v1/users/login
• Request Body:

  {
    "username": "string",
    "password": "string"
  }
  

• Response:

  {
    "token": "string",
    "expires_at": "string"
  }
  

（省略后续内容...）

### 7.3 代码生成与审查

规格文档确认后，MiMo Code 会自动调用 `code-executor` Skill 生成代码：

```go
// internal/handler/user_handler.go

package handler

import (
    "net/http"
    "github.com/gin-gonic/gin"
    "github.com/yourusername/user-service/internal/service"
)

type UserHandler struct {
    userService *service.UserService
}

func NewUserHandler(userService *service.UserService) *UserHandler {
    return &UserHandler{userService: userService}
}

func (h *UserHandler) Register(c *gin.Context) {
    var req struct {
        Username string `json:"username" binding:"required,min=3,max=50"`
        Email    string `json:"email" binding:"required,email"`
        Password string `json:"password" binding:"required,min=8"`
    }
    
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    
    user, err := h.userService.Register(req.Username, req.Email, req.Password)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }
    
    c.JSON(http.StatusCreated, gin.H{
        "user_id":   user.ID,
        "created_at": user.CreatedAt,
    })
}

// 省略后续代码...

代码生成后，MiMo Code 会自动调用 code-reviewer Skill 进行代码审查：

🔍 代码审查报告

## 发现的问题

### 问题 1：密码明文传输
- **位置**: internal/handler/user_handler.go:23
- **严重性**: 高
- **描述**: 密码在 JSON 请求体中明文传输，应通过 HTTPS + 请求体加密来保护
- **建议**: 在文档中明确要求 HTTPS，并考虑添加请求体加密选项

### 问题 2：错误信息泄露敏感信息
- **位置**: internal/handler/user_handler.go:31
- **严重性**: 中
- **描述**: 直接将 `err.Error()` 返回给客户端，可能泄露敏感信息
- **建议**: 使用统一的错误处理中间件，对外部响应使用通用错误消息

（省略后续内容...）

7.4 测试驱动开发

代码审查通过后，MiMo Code 会调用 test-writer Skill 生成测试用例：

// internal/service/user_service_test.go

package service

import (
    "testing"
    "github.com/stretchr/testify/assert"
    "github.com/yourusername/user-service/internal/model"
    "github.com/yourusername/user-service/internal/repository"
)

func TestUserService_Register(t *testing.T) {
    // 初始化测试环境
    repo := repository.NewMockUserRepository()
    userService := NewUserService(repo)
    
    t.Run("成功注册新用户", func(t *testing.T) {
        user, err := userService.Register("testuser", "test@example.com", "password123")
        
        assert.NoError(t, err)
        assert.NotEmpty(t, user.ID)
        assert.Equal(t, "testuser", user.Username)
    })
    
    t.Run("用户名已存在", func(t *testing.T) {
        // 先创建一个用户
        userService.Register("existinguser", "existing@example.com", "password123")
        
        // 尝试创建同名用户
        _, err := userService.Register("existinguser", "newemail@example.com", "password123")
        
        assert.Error(t, err)
        assert.Contains(t, err.Error(), "username already exists")
    })
    
    // 省略后续测试用例...
}

7.5 调试与修复

运行测试后，MiMo Code 会调用 debugger Skill 自动修复测试失败：

# 运行测试
go test ./...

# 测试失败输出
--- FAIL: TestUserService_Login (0.02s)
    user_service_test.go:45: 
        Error Trace: user_service_test.go:45
        Error:      Expected token to be valid for 24 hours, but got 23 hours
        Test:       TestUserService_Login

# MiMo Code 自动分析失败原因
# 发现问题：JWT 令牌的过期时间计算未考虑时区

# 自动修复

// internal/service/user_service.go (修复后)

func (s *UserService) Login(username, password string) (string, error) {
    // ... 省略认证逻辑 ...
    
    // 修复前：token := jwt.NewWithClaims(jwt.SigningMethodRS256, jwt.MapClaims{
    //     "user_id": user.ID,
    //     "exp":     time.Now().Add(24 * time.Hour).Unix(),
    // })
    
    // 修复后：
    token := jwt.NewWithClaims(jwt.SigningMethodRS256, jwt.MapClaims{
        "user_id": user.ID,
        "exp":     time.Now().UTC().Add(24 * time.Hour).Unix(),
    })
    
    // ... 省略后续逻辑 ...
}

7.6 验证与合并

所有测试通过后，MiMo Code 会调用 verifier Skill 验证实现是否满足规格文档中的所有要求，然后调用 merger Skill 执行 Git 合并操作：

# 验证通过

✅ 所有规格要求已满足
✅ 所有测试用例已通过
✅ 代码审查已通过

# 执行合并
git add .
git commit -m "feat: implement user service with JWT authentication"
git merge feature/user-service

8. 性能优化：Max Mode 与并行推理

8.1 Max Mode：并行 Best-of-N 推理

MiMo Code 引入了 Max Mode，这是一种并行推理模式，通过在每个决策点生成多个候选方案，然后通过 Majority Voting 和 Best-of-N Self-Verification 选择最优路径。

8.1.1 Max Mode 的工作原理

决策点：需要选择下一步行动
    ↓
并行生成 N 个候选方案（N 默认为 5）
    ↓
┌─────────────────────────────────────┐
│ 候选方案 1: 修改文件 A              │
│ 候选方案 2: 修改文件 B              │
│ 候选方案 3: 修改文件 A (不同实现)   │
│ 候选方案 4: 先运行测试再修改        │
│ 候选方案 5: 修改文件 A 和 B         │
└─────────────────────────────────────┘
    ↓
Majority Voting：统计候选方案中的共识
    ↓
Best-of-N Self-Verification：对 top-K 候选方案进行验证
    ↓
选择最优方案执行

8.1.2 Max Mode 的性能提升

根据官方数据，在 SWE-Bench Pro 基准测试中，Max Mode 相比单次采样提升了 10-20% 的通过率，代价是约 4-5 倍的 Token 消耗。

8.1.3 启用 Max Mode

Max Mode 目前是实验性功能，需要在配置文件中手动启用：

// .mimocode/mimocode.json
{
  "experimental": {
    "maxMode": true,
    "maxModeN": 5,           // 并行生成的候选方案数量
    "maxModeTopK": 3,        // 进入 Self-Verification 的 top-K 方案
    "maxModeVerificationModel": "mimo-v2.5-pro"  // 验证使用的模型
  }
}

8.2 上下文窗口优化策略

8.2.1 Token 预算控制

MiMo Code 通过 Token 预算来控制注入上下文的内容量：

{
  "checkpoint": {
    "tokenBudget": {
      "checkpoint": 1000,    // Checkpoint 内容最多占 1000 Token
      "memory": 2000,        // 记忆内容最多占 2000 Token
      "notes": 500,          // 笔记内容最多占 500 Token
      "taskProgress": 800,   // 任务进度最多占 800 Token
      "recentMessages": 2000 // 最近消息最多占 2000 Token
    }
  }
}

8.2.2 重要性排序算法

MiMo Code 使用以下因素来计算记忆条目的重要性：

def calculate_importance(memory_entry):
    """
    计算记忆条目的重要性分数
    
    Args:
        memory_entry: 记忆条目对象
    
    Returns:
        重要性分数（0-1 之间）
    """
    # 因素 1：访问频率（Access Frequency）
    access_freq_score = min(memory_entry.access_count / 100, 1.0)
    
    # 因素 2：最近访问时间（Recency）
    hours_since_access = (now() - memory_entry.last_accessed).total_seconds() / 3600
    recency_score = 1.0 / (1.0 + hours_since_access / 24)  # 衰减函数
    
    # 因素 3：与当前任务的相关性（Relevance）
    relevance_score = calculate_relevance(memory_entry.content, current_task)
    
    # 因素 4：用户标记的重要性（User Flag）
    user_flag_score = 1.0 if memory_entry.user_flagged else 0.0
    
    # 综合评分（加权平均）
    final_score = (
        0.3 * access_freq_score +
        0.2 * recency_score +
        0.4 * relevance_score +
        0.1 * user_flag_score
    )
    
    return final_score

9. Self-Improvement：Dream 与 Distill 机制

9.1 Dream：从会话痕迹中提取持久知识

Dream 机制是 MiMo Code 实现"跨 Session 经验积累"的核心。它通过分析最近的会话痕迹，自动提取有价值的知识，并将其写入 MEMORY.md。

9.1.1 Dream 的执行流程

触发 Dream（手动或自动）
    ↓
扫描最近的会话痕迹（默认最近 10 个 Session）
    ↓
提取以下类型的知识：
  - 项目背景信息
  - 编码规范和最佳实践
  - 架构决策和理由
  - 已知坑点和解决方案
  - 常用命令和工具链
    ↓
更新 MEMORY.md
  - 新增发现的知识
  - 更新过时的条目
  - 移除无效的内容
    ↓
输出 Dream 报告

9.1.2 Dream 报告示例

✨ Dream 完成

## 新增知识
- 记录到 MEMORY.md：项目使用 gRPC 而非 REST 的原因（来自 Session #123）
- 记录到 MEMORY.md：Redis 连接池在 Kubernetes 环境中的特殊配置（来自 Session #124）

## 更新条目
- 更新 MEMORY.md：Go 版本要求从 1.21 升级到 1.22（来自 Session #125）

## 移除过时内容
- 移除 MEMORY.md：已废弃的 `pkg/oldauth` 包相关说明（来自 Session #120，该包已被删除）

## 统计
- 扫描会话数：10
- 新增条目：2
- 更新条目：1
- 移除条目：1

9.2 Distill：将重复工作流蒸馏为可复用技能

Distill 机制是 MiMo Code 实现"自我进化"的关键。它通过分析最近的工作记录，发现重复的手动工作流，并将其打包为可复用的 Skills、Subagents 或 Commands。

9.2.1 Distill 的发现算法

def discover_repeatable_workflows(recent_sessions, min_occurrences=3, confidence_threshold=0.8):
    """
    发现可复用的重复工作流
    
    Args:
        recent_sessions: 最近的会话记录
        min_occurrences: 最小出现次数
        confidence_threshold: 置信度阈值
    
    Returns:
        候选工作流列表
    """
    # 步骤 1：提取所有工作流模式
    workflows = []
    for session in recent_sessions:
        workflows.extend(extract_workflows(session))
    
    # 步骤 2：聚类相似的工作流
    clustered = cluster_similar_workflows(workflows)
    
    # 步骤 3：过滤出重复出现的工作流
    repeated = [c for c in clustered if len(c) >= min_occurrences]
    
    # 步骤 4：计算置信度
    candidates = []
    for workflow_cluster in repeated:
        confidence = calculate_confidence(workflow_cluster)
        if confidence >= confidence_threshold:
            candidates.append({
                "workflow": workflow_cluster[0],  # 使用第一个作为代表
                "occurrences": len(workflow_cluster),
                "confidence": confidence,
            })
    
    return candidates

9.2.2 Distill 生成的 Skill 示例

假设 Distill 发现你在多个 Session 中都在执行"为 Go 项目添加 Prometheus 监控"的工作流，它会生成如下 Skill：

# Skill: add-prometheus-monitoring

## 触发条件
当需要从零为 Go 项目添加 Prometheus 监控时触发此 Skill。

## 执行步骤

1. 添加依赖
   ```bash
   go get github.com/prometheus/client_golang/prometheus
   go get github.com/prometheus/client_golang/prometheus/promhttp

2. 创建监控初始化文件

   // internal/monitoring/metrics.go
   
   package monitoring
   
   import (
       "github.com/prometheus/client_golang/prometheus"
       "github.com/prometheus/client_golang/prometheus/promauto"
   )
   
   var (
       RequestDuration = promauto.NewHistogramVec(
           prometheus.HistogramOpts{
               Name: "http_request_duration_seconds",
               Help: "Duration of HTTP requests in seconds",
           },
           []string{"method", "route", "status_code"},
       )
   
       RequestTotal = promauto.NewCounterVec(
           prometheus.CounterOpts{
               Name: "http_requests_total",
               Help: "Total number of HTTP requests",
           },
           []string{"method", "route"},
       )
   )
   

3. 注册 Prometheus Handler

   // main.go
   
   import (
       "net/http"
       "github.com/prometheus/client_golang/prometheus/promhttp"
   )
   
   func main() {
       // ... 省略其他初始化 ...
   
       http.Handle("/metrics", promhttp.Handler())
   
       // ... 省略后续逻辑 ...
   }
   

4. 在中间件中记录指标

   // internal/middleware/monitoring.go
   
   package middleware
   
   import (
       "net/http"
       "time"
       "your-project/internal/monitoring"
   )
   
   func MonitoringMiddleware(next http.Handler) http.Handler {
       return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
           start := time.Now()
   
           // 包装 ResponseWriter 以获取状态码
           rw := &responseWriter{w, http.StatusOK}
           next.ServeHTTP(rw, r)
   
           duration := time.Since(start).Seconds()
           monitoring.RequestDuration.WithLabelValues(
               r.Method,
               r.URL.Path,
               http.StatusText(rw.statusCode),
           ).Observe(duration)
   
           monitoring.RequestTotal.WithLabelValues(
               r.Method,
               r.URL.Path,
           ).Inc()
       })
   }
   
   type responseWriter struct {
       http.ResponseWriter
       statusCode int
   }
   
   func (rw *responseWriter) WriteHeader(code int) {
       rw.statusCode = code
       rw.ResponseWriter.WriteHeader(code)
   }
   

使用说明

将此 Skill 保存为 .mimocode/skills/add-prometheus-monitoring.md，
然后在 MiMo Code 中通过以下命令使用：

/add-prometheus-monitoring

---

## 10. MCP 集成：扩展 MiMo Code 的能力边界

MCP（Model Context Protocol）是一个开放的协议，用于让 AI 模型访问外部工具和数据源。MiMo Code 深度集成了 MCP，支持连接任意兼容 MCP 的服务器。

### 10.1 MCP 的配置方式

在 `.mimocode/mimocode.json` 中配置 MCP 服务器：

```json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/files"],
      "env": {
        "ALLOWED_PATHS": "/path/to/allowed/files"
      }
    },
    "database": {
      "command": "python3",
      "args": ["/path/to/mcp-server-database/main.py"],
      "env": {
        "DB_URL": "postgresql://user:pass@localhost:5432/mydb"
      }
    },
    "custom-api": {
      "url": "https://my-mcp-server.com/mcp",
      "headers": {
        "Authorization": "Bearer your-token"
      }
    }
  }
}

10.2 常用的 MCP 服务器

10.3 自定义 MCP 服务器开发

如果现有的 MCP 服务器无法满足你的需求，你可以使用任意编程语言开发自定义 MCP 服务器。

以下是一个简单的 Python MCP 服务器示例，它提供了一个"获取天气"工具：

# custom_mcp_server.py

import asyncio
import json
from mcp import Server, Tool

server = Server("custom-weather-server")

@server.tool()
def get_weather(city: str) -> str:
    """
    获取指定城市的天气
    
    Args:
        city: 城市名称
    
    Returns:
        天气描述
    """
    # 这里应该是调用真实的天气 API
    # 为了演示，我们返回一个模拟结果
    weather_data = {
        "北京": "晴，25°C",
        "上海": "多云，28°C",
        "深圳": "小雨，30°C",
    }
    return weather_data.get(city, "天气数据不可用")

if __name__ == "__main__":
    asyncio.run(server.run())

然后在 MiMo Code 中配置这个自定义 MCP 服务器：

{
  "mcpServers": {
    "weather": {
      "command": "python3",
      "args": ["/path/to/custom_mcp_server.py"]
    }
  }
}

11. 语音输入：TenVAD + MiMo ASR 实时流式识别

MiMo Code 支持实时流式语音输入，由 TenVAD（语音活动检测）和 MiMo ASR（自动语音识别）提供支持。

11.1 语音输入的工作原理

用户按下语音输入快捷键（默认 Ctrl+V）
    ↓
TenVAD 实时检测语音活动
    ↓
检测到语音开始 → 开始录音
检测到语音暂停 → 结束当前语音段
    ↓
将语音段发送到 MiMo ASR 模型
    ↓
MiMo ASR 返回转录文本
    ↓
将转录文本增量插入到输入框

11.2 启用语音输入

# 在 MiMo Code 中启用语音输入
/voice on

# 配置语音输入使用的模型
/voice config

? 选择 ASR 模型：
  ❯ mimo-v2.5-asr (MiMo 平台用户专用)
    whisper-large-v3 (OpenAI 兼容 API)
    custom (自定义 ASR 模型)

11.3 WSL 环境的语音输入配置

在 WSL 环境中使用语音输入需要额外配置 PulseAudio：

# 安装依赖
sudo apt install -y sox pulseaudio libasound2-plugins

# 配置 PulseAudio 服务器
export PULSE_SERVER=unix:/mnt/wslg/PulseServer

# 验证配置
pactl info

11.4 SSH 远程主机的语音输入配置

如果你的 MiMo Code 运行在远程主机上，但希望在本地 Mac 上输入语音，可以配置 SSH 远程音频转发：

# Mac（本地）
brew install pulseaudio
pulseaudio --load="module-native-protocol-tcp auth-ip-acl=127.0.0.1" --exit-idle-time=-1 --daemonize

# 添加以下内容到 ~/.ssh/config
Host remote-host
    RemoteForward 4713 127.0.0.1:4713

# 远程主机
apt install -y pulseaudio pulseaudio-utils sox
export PULSE_SERVER=tcp:127.0.0.1:4713

# 验证配置
pactl info

12. 配置深度定制：mimocode.json 完全参考

MiMo Code 的配置文件支持项目级（.mimocode/mimocode.json）和全局级（~/.config/mimocode/mimocode.json）两种级别。

12.1 完整配置参考

{
  // 提供商配置
  "providers": [
    {
      "name": "mimo-auto",
      "type": "mimo",
      "apiUrl": "https://platform.xiaomimimo.com/api/v1",
      "apiKey": "auto",  // 匿名通道，自动获取
      "models": ["mimo-v2.5", "mimo-v2.5-pro", "mimo-v2.5-asr"]
    },
    {
      "name": "openai",
      "type": "openai",
      "apiUrl": "https://api.openai.com/v1",
      "apiKey": "sk-your-openai-key",
      "models": ["gpt-5.4", "gpt-5.4-codex"]
    },
    {
      "name": "anthropic",
      "type": "anthropic",
      "apiUrl": "https://api.anthropic.com",
      "apiKey": "sk-ant-your-anthropic-key",
      "models": ["claude-opus-4.6", "claude-sonnet-4.6"]
    },
    {
      "name": "openrouter",
      "type": "openai-compatible",  // OpenRouter 使用 OpenAI 兼容 API
      "apiUrl": "https://openrouter.ai/api/v1",
      "apiKey": "sk-or-your-openrouter-key",
      "models": ["anthropic/claude-opus-4.6", "openai/gpt-5.4-codex"]
    }
  ],
  
  // 默认模型
  "defaultModel": "mimo-v2.5-pro",
  
  // Agent 配置
  "agents": {
    "build": {
      "description": "Full tool permissions for development",
      "tools": ["all"],
      "maxTokens": 8192
    },
    "plan": {
      "description": "Read-only analysis mode",
      "tools": ["read", "search", "analyze"],
      "maxTokens": 4096
    },
    "compose": {
      "description": "Specs-driven development orchestration",
      "tools": ["all"],
      "maxTokens": 16384,
      "skills": ["spec-writer", "code-executor", "code-reviewer", "test-writer", "debugger", "verifier", "merger"]
    }
  },
  
  // Checkpoint 配置
  "checkpoint": {
    "enabled": true,
    "triggerThreshold": 0.8,  // 上下文窗口使用率达到 80% 时触发
    "tokenBudget": {
      "checkpoint": 1000,
      "memory": 2000,
      "notes": 500,
      "taskProgress": 800,
      "recentMessages": 2000
    }
  },
  
  // 记忆配置
  "memory": {
    "enabled": true,
    "database": ".mimocode/memory.db",
    "autoDream": true,  // 自动执行 Dream
    "dreamInterval": 3600,  // 每 3600 秒（1 小时）自动执行一次 Dream
    "maxEntries": 1000,  // 最多保留 1000 条记忆
    "expirationDays": 30  // 30 天未访问的记忆会被评估是否移除
  },
  
  // 子代理配置
  "subagents": {
    "enabled": true,
    "maxParallel": 5,  // 最多并行 5 个子代理
    "timeout": 300,  // 子代理超时时间（秒）
    "lifecycleCallbacks": true  // 启用生命周期回调
  },
  
  // Goal 配置
  "goal": {
    "enabled": true,
    "judgeModel": "mimo-v2.5-pro",  // 裁判模型
    "judgeTemperature": 0.0  // 裁判模型的温度参数（使用低温度以保证判断一致性）
  },
  
  // Compose 模式配置
  "compose": {
    "enabled": true,
    "defaultSkills": ["spec-writer", "code-executor", "code-reviewer", "test-writer", "debugger", "verifier", "merger"],
    "autoMerge": false  // 禁用自动合并，需要手动确认
  },
  
  // MCP 配置
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
      "env": {}
    }
  },
  
  // 语音输入配置
  "voice": {
    "enabled": true,
    "asrModel": "mimo-v2.5-asr",  // ASR 模型（仅 MiMo 平台可用）
    "voiceControlModel": "mimo-v2.5",  // 语音控制模型（可用于 OpenRouter 等）
    "vadSensitivity": 0.5,  // VAD 灵敏度（0-1）
    "autoPunctuation": true  // 自动添加标点符号
  },
  
  // 实验性功能
  "experimental": {
    "maxMode": false,
    "maxModeN": 5,
    "maxModeTopK": 3,
    "maxModeVerificationModel": "mimo-v2.5-pro"
  },
  
  // UI 配置
  "ui": {
    "theme": "dark",
    "fontSize": 14,
    "lineNumbers": true,
    "minimap": false
  },
  
  // 快捷键配置
  "keybindings": {
    "toggleVoice": "Ctrl+V",
    "toggleAgent": "Tab",
    "executeCommand": "Enter",
    "cancel": "Escape"
  }
}

13. 基于 MiMo Code 构建团队 AI 编程工作流

13.1 团队级配置共享

在团队环境中，你可以通过 Git 共享 MiMo Code 的项目级配置文件：

# 将项目级配置添加到 Git
git add .mimocode/mimocode.json
git commit -m "chore: add MiMo Code project configuration"
git push

其他团队成员拉取代码后，只需要运行 mimo 就会自动加载项目级配置。

13.2 MEMORY.md 的团队协作规范

为了确保 MEMORY.md 在团队环境中的一致性，建议制定以下规范：

1. 结构化存储：使用固定的章节结构（项目背景、编码规范、架构决策、已知坑点）。
2. 时效性标记：为每个记忆条目添加最后验证日期。
3. 责任归属：重大架构决策的记录需要包含提出者和批准者。
4. 定期审查：每周团队会议中审查 MEMORY.md，确保其时效性。

示例 MEMORY.md：

# 项目记忆

## 项目背景
- 本项目是一个微服务架构的电商系统
- 技术栈：Go + gRPC + PostgreSQL + Redis
- 最后验证：2026-06-21

## 编码规范
- 所有错误处理必须使用 `pkg/errors` 包装
- 禁止在业务代码中直接使用 `fmt.Errorf`
- 最后验证：2026-06-21，提出者：@zhangsan，批准者：@lisi

## 架构决策
- 选择 gRPC 而非 REST 的原因：内部服务调用需要严格的类型安全
- 提出者：@wangwu，批准者：@lisi，日期：2026-06-15

## 已知坑点
- Redis 连接池在 Kubernetes 环境中需要特殊处理，参见 `docs/redis-in-k8s.md`
- 最后验证：2026-06-20

13.3 CI/CD 集成

MiMo Code 可以通过 --non-interactive 模式集成到 CI/CD 流水线中：

# .github/workflows/ai-code-review.yml

name: AI Code Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  ai-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Install MiMo Code
        run: npm install -g @mimo-ai/cli
      
      - name: Run AI Code Review
        env:
          MIMO_API_KEY: ${{ secrets.MIMO_API_KEY }}
        run: |
          mimo --non-interactive "审查这个 PR 的代码质量，重点关注：
          1. 错误处理是否完善
          2. 是否有潜在的性能问题
          3. 是否符合项目的编码规范
          
          PR 标题：${{ github.event.pull_request.title }}
          PR 描述：${{ github.event.pull_request.body }}
          " --output review-report.md
      
      - name: Post Review Comment
        uses: actions/github-script@v6
        with:
          script: |
            const fs = require('fs');
            const report = fs.readFileSync('review-report.md', 'utf8');
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: report
            });

14. 安全与隐私：本地优先架构的设计哲学

14.1 本地优先架构的优势

MiMo Code 采用了"本地优先"（Local-First）的架构设计，具有以下优势：

1. 数据隐私：你的代码和项目信息不会离开本地环境，除非你选择使用云端模型。
2. 离线能力：核心功能可以在离线环境下运行（使用本地模型时）。
3. 低延迟：本地执行避免了网络往返延迟。
4. 成本控制：使用本地模型可以避免 API 调用费用。

14.2 数据安全最佳实践

尽管 MiMo Code 是本地优先的，但在使用过程中仍需注意以下安全最佳实践：

1. API Key 管理：不要将 API Key 硬编码到配置文件中，应使用环境变量或密钥管理工具。

   # 错误做法
   echo '{"apiKey": "sk-your-key"}' > .mimocode/mimocode.json
   
   # 正确做法
   export MIMO_API_KEY="sk-your-key"
   

2. .gitignore 配置：确保敏感配置文件不会被提交到 Git。

   # .gitignore
   
   .mimocode/mimocode.json  # 如果包含 API Key
   .mimocode/memory.db       # 可能包含敏感信息
   

3. 访问控制：在多用户环境中，确保 MiMo Code 的配置文件的访问权限正确设置。

   chmod 600 .mimocode/mimocode.json
   

14.3 使用本地模型

为了彻底消除数据隐私风险，你可以使用本地部署的开源模型：

# 安装 Ollama（本地模型运行工具）
curl -fsSL https://ollama.com/install.sh | sh

# 下载 MiMo V2.5 模型（假设已支持 Ollama）
ollama pull mimo-v2.5

# 配置 MiMo Code 使用本地模型

{
  "providers": [
    {
      "name": "local-mimo",
      "type": "ollama",
      "apiUrl": "http://localhost:11434",
      "models": ["mimo-v2.5"]
    }
  ],
  "defaultModel": "local-mimo/mimo-v2.5"
}

15. 未来展望：AI Dev OS 的生态演进

15.1 从 AI 编程工具到 AI Dev OS

MiMo Code 的终极目标不仅仅是成为一个"更好的 AI 编程助手"，而是演变为一个AI Dev OS（AI 开发操作系统）。

在这个愿景中：

1. AI Dev OS 是开发者的"数字分身"：它深度理解你的项目、你的编码习惯、你的技术栈偏好，并能够自主地完成开发任务。
2. AI Dev OS 是开发工具的"统一入口"：它通过 MCP 协议集成所有开发工具（Git、Docker、Kubernetes、云平台等），成为开发者与整个开发工具链交互的统一入口。
3. AI Dev OS 是团队知识的"活字典"：它通过 Dream 和 Distill 机制，持续地从团队的工作实践中学习，并能够将经验传递给新成员。

15.2 小米 MiMo 的生态布局

小米 MiMo 团队在 AI 领域的生态布局已经初具规模：

1. MiMo 大模型：MiMo V2.5 和 MiMo V2.5 Pro，支持多模态输入，1M Token 上下文窗口。
2. MiMo Code：终端原生的 AI 编程助手。
3. MiMo Platform：提供模型 API 和 OAuth 登录服务。
4. Orbit 计划：百万亿 Token 激励计划，面向全球开发者免费发放 Tokens。

15.3 开源社区的贡献机会

作为一个 MIT 协议的开源项目，MiMo Code 欢迎社区贡献。以下是一些适合社区贡献的方向：

1. 新的 Skills：为 Compose 模式开发新的 Skills。
2. 新的 MCP 服务器：开发用于特定工具的 MCP 服务器。
3. 新的 Agent 模式：设计并实现新的 Agent 模式（类似于 build、plan、compose）。
4. 性能优化：优化 Checkpoint、记忆系统、子代理编排等核心机制的性能。
5. 文档改进：改进用户文档和开发者文档。

16. 总结：国产 AI 编程工具的里程碑

MiMo Code 的发布，标志着国产 AI 编程工具进入了一个全新的阶段。它的出现，不仅在技术架构上实现了多项创新（持久化记忆、Checkpoint、子代理编排、Goal 机制、Compose 模式、Self-Improvement 等），更在开源生态、本土化支持、免费额度等方面展现出了与国际顶尖产品（如 Claude Code）竞争的实力。

对于中国开发者而言，MiMo Code 的意义不仅仅是"又一个 AI 编程工具"，而是：

1. 技术自主可控的保障：基于开源协议，你可以深入了解其实现细节，并根据需要进行定制。
2. 本土化支持的完善：对中文输入、国产模型、本地化部署的深度优化。
3. 成本优势的显著：MiMo Auto 限时免费，大幅降低了 AI 编程的门槛。

当然，MiMo Code 目前仍处于 V0.1.0 的早期阶段，存在以下功能缺失：

• UI 交互不够流畅（相比 Cursor 等图形界面工具）
• 调试工具不够完善
• 文档和社区生态仍在建设中

但我们相信，在开源社区的共同努力下，MiMo Code 有望成为 AI 编程工具领域的"Linux"——开放、强大、可定制，并成为国产 AI 工具走向世界的一个里程碑。

参考资源

1. MiMo Code GitHub 仓库：https://github.com/XiaomiMiMo/MiMo-Code
2. MiMo Code 官方网站：https://mimo.xiaomi.com/coder
3. MiMo Code 官方博客：https://mimo.xiaomi.com/en/blog/mimo-code-long-horizon
4. MiMo 大模型平台：https://platform.xiaomimimo.com
5. OpenCode 项目：https://github.com/opencodeai/opencode
6. MCP 协议规范：https://modelcontextprotocol.io

作者注：本文基于 MiMo Code V0.1.0 版本撰写，随着项目的快速迭代，部分细节可能在未来版本中发生变化。建议读者在使用时参考最新的官方文档。

文章统计：全文约 18,000 字，代码示例 15 个，配置示例 8 个，架构图（文字描述）12 个。

发布日期：2026 年 6 月 22 日