OpenCode 深度拆解：当 158K Star 的开源项目决定「干掉 Claude Code」——从 Effect-TS 架构到 Provider-Agnostic 的终端 AI 编程革命

158K Star、MIT 许可、完全开源、75+ 模型提供商、终端优先——OpenCode 如何在 Claude Code 闭源统治下，用架构开放性赢得开发者。

一、引言：AI 编程工具的「厂商锁定」困局

2026 年的 AI 编程助手赛道，正处于一个微妙的十字路口。

Claude Code 凭借 Anthropic 的推理能力一骑绝尘，Cursor 靠订阅制牢牢绑定用户，GitHub Copilot 深度嵌入 GitHub 生态无法自拔。表面上看，开发者拥有了前所未有的 AI 辅助编程能力；但骨子里，你写的每一行代码、调用的每一次 API、积累的每一个上下文，都被锁在了某个厂商的围墙里。

Claude Code 不支持切换到 GPT-4o——因为 Anthropic 不希望你这么做。Cursor 无法使用 DeepSeek——因为它绑定了特定订阅。Copilot 的代码补全依赖 GitHub 的闭源模型——你甚至无法确认它用了什么训练数据。

这不是技术问题，这是架构问题。

当一个工具的模型层、推理层、上下文层全部耦合在一起时，你得到的不是"最佳体验"，而是"最高锁定"。

OpenCode 的诞生，正是对这一困局的正面回应。

由 terminal.shop 创建者和 Neovim 爱好者主导，OpenCode 以一个看似简单却极其激进的理念切入：100% 开源、完全模型无关、终端优先。截至 2026 年 8 月，它在 GitHub 上已获得超过 158K Star，月活跃开发者超过 250 万，成为增长最快的开源 AI 编程工具。

但 Star 数只是一个数字。真正让 OpenCode 值得深入拆解的，是它背后那一套精心设计的架构——Effect-TS 的函数式依赖注入、Vercel AI SDK 的多提供商抽象、Event Sourcing 的状态同步、以及四层可定制的扩展体系。

这不是又一个"套壳调 API"的工具。这是一次从内核到生态的架构级创新。

二、核心定位：OpenCode vs Claude Code 的本质差异

在深入架构之前，先厘清 OpenCode 的核心定位。它的官方 FAQ 直接对标 Claude Code，两者功能相近，但差异鲜明：

核心差异可以用一句话概括：Claude Code 是一个产品，OpenCode 是一个平台。

Claude Code 的价值在于 Anthropic 的模型推理能力——你用它，本质上是在租用 Anthropic 的大脑。OpenCode 的价值在于架构的开放性——你可以用任何模型、自己托管、自己改代码、自己定义 Agent 行为。

这种差异在架构层面有深刻体现，下面我们逐一拆解。

三、架构全景：客户端/服务器解耦的革命性设计

OpenCode 最具前瞻性的设计，是客户端/服务器解耦架构。这使得 TUI 仅是众多潜在客户端之一：

3.1 四层架构模型

┌─────────────────────────────────────────────────┐
│                 客户端层 (Client)                  │
│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│  │   TUI   │ │   Web   │ │ Desktop │ │  IDE    │ │
│  │ SolidJS │ │ SolidJS │ │  Tauri  │ │ Extension│
│  └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘ │
│       └───────────┼───────────┼───────────┘      │
│                   │  HTTP + WebSocket             │
├───────────────────┼──────────────────────────────┤
│              服务层 (Server)                       │
│  ┌────────────────┴────────────────────────┐     │
│  │  Hono HTTP Server + mDNS Service Discovery│    │
│  ├──────────────────────────────────────────┤     │
│  │  Session Manager │ Agent Router │ Tool Registry│
│  │  Permission System │ Event Bus │ Sync Event   │
│  ├──────────────────────────────────────────┤     │
│  │  Provider Abstraction (Vercel AI SDK)     │     │
│  │  LSP Integration │ MCP Protocol            │     │
│  └──────────────────────────────────────────┘     │
├───────────────────────────────────────────────────┤
│              基础层 (Foundation)                    │
│  Bun Runtime │ SQLite │ Drizzle ORM │ Effect-TS   │
│  Zod Validation │ Bus/SyncEvent │ Permission      │
└───────────────────────────────────────────────────┘

3.2 为什么这个架构如此重要？

传统的 AI 编程工具（如 Claude Code）采用单体架构——推理引擎、UI 渲染、文件操作、命令执行全部耦合在一个进程里。这意味着：

• 换 UI 必须换整个工具：想用 Web 界面？重新写一遍。想用 IDE 插件？再写一遍。
• 换模型必须换整个工具：想从 Claude 换到 GPT？做不到，因为 API 调用逻辑写死在核心里。
• 远程控制不可能：想用手机发指令让电脑执行？架构不支持，因为 UI 和推理在同一个进程里。

OpenCode 的解耦架构彻底解决了这些问题：

// packages/opencode/src/server/server.ts
import { Hono } from "hono"
import { mDNS } from "opencode/server/mdns"

const app = new Hono()

// 服务通过 mDNS 广播，局域网内客户端自动发现
Server.listen({
  port: 4096,
  hostname: "0.0.0.0",
  mdns: true,
  mdnsDomain: "opencode",
  cors: ["https://app.opencode.ai"],
})

服务器启动后，通过 mDNS（Multicast DNS） 在局域网内自动广播服务地址。TUI 客户端、Web 客户端、Desktop 客户端——甚至是未来你手机上的移动端——都可以通过 HTTP + WebSocket 连接到同一个服务实例。

这意味着你可以用手机发一句"帮我重构这个函数"，电脑端的 OpenCode 服务就会执行重构操作——与 OpenClaw 的 ClawBot 理念一脉相承。

3.3 技术栈选择的深层逻辑

注意 Bun + Hono + SolidJS 的组合。 这不是随便选的。Bun 的启动速度（冷启动 5.5ms）让 TUI 响应极快；Hono 的轻量级 HTTP 框架让服务端可以跑在边缘设备上；SolidJS 的细粒度响应式让 TUI 界面无需 Virtual DOM 即可高效更新。

这三者共同构成了一个"极致轻量 + 极致响应"的技术栈，完美适配终端优先的理念。

四、Effect-TS：函数式编程在 AI 工具中的工程实践

OpenCode 的代码库里有一个在 AI 工具中极为罕见的技术选择：Effect-TS。

这不是一个常见的 UI 框架或工具库，而是一个函数式效果系统（Functional Effect System），用于管理依赖注入、错误处理、并发控制和资源生命周期。在传统的 Node.js 项目中，这些功能通常散落在不同的库和模式中；Effect-TS 将它们统一到了一个类型安全的框架里。

4.1 为什么 Effect-TS 重要？

一个 AI 编程工具面临的核心工程挑战是：它需要同时管理大量异步操作、外部依赖和错误场景。

以一次简单的"用户请求 → AI 推理 → 工具调用 → 结果返回"为例，底层涉及：

• HTTP 连接管理
• LLM API 调用（可能超时、限流、模型切换）
• 工具执行（文件读写、命令执行、LSP 查询）
• 权限检查（每个工具调用都需要验证）
• 事件发布（通知 UI 更新）
• 会话状态管理（上下文压缩、历史记录）

在传统代码中，这些异步操作会变成层层嵌套的 Promise 链和 try-catch。Effect-TS 的价值在于：它将所有这些操作统一为类型安全的 Effect 值，编译器可以在编译时帮你检查依赖是否正确注入、错误是否被处理、资源是否正确释放。

4.2 Effect-TS 服务架构模式

OpenCode 使用 Effect-TS 实现了一个优雅的依赖注入和服务管理架构：

// 1. 定义服务接口
export interface Interface {
  readonly get: (id: string) => Effect.Effect<Info>
  readonly list: () => Effect.Effect<Info[]>
}

// 2. 创建服务类（使用 ServiceMap 实现服务注册）
export class Service extends ServiceMap.Service<Service, Interface>()(
  "@opencode/ModuleName"
) {}

// 3. 实现服务层（Layer 是 Effect-TS 的依赖注入单元）
export const layer = Layer.effect(
  Service,
  Effect.gen(function* () {
    const config = yield* Config.Service // 自动注入配置依赖
    // ... 实现逻辑
    return Service.of({ get, list })
  })
)

// 4. 组合依赖（声明式依赖图）
export const defaultLayer = layer.pipe(
  Layer.provide(Config.defaultLayer),
)

// 5. 创建运行时并导出同步接口
const { runPromise } = makeRuntime(Service, defaultLayer)
export async function get(id: string) {
  return runPromise((svc) => svc.get(id))
}

这段代码的精妙之处在于：

• ServiceMap.Service 自动创建服务的类型标识，避免硬编码的字符串 key
• Layer.effect 将异步操作包装为 Effect 值，编译器会检查依赖链
• yield* Config.Service 是 Effect-TS 的"yield"语法——它不是 generator，而是声明式依赖声明
• Layer.provide 在编译时构建依赖图，运行时自动解析

4.3 Effect-TS vs 传统模式的对比

传统方式（以 Session 管理为例）：

// 传统方式：手动管理依赖和错误
class SessionManager {
  constructor(
    private config: Config,
    private db: Database,
    private bus: EventBus,
    private permission: PermissionService
  ) {}
  
  async createSession(projectId: string): Promise<Session> {
    try {
      const config = await this.config.load()
      const hasPermission = await this.permission.check('session.create')
      if (!hasPermission) throw new PermissionError()
      const session = await this.db.insert('sessions', { projectId })
      await this.bus.publish('session.created', session)
      return session
    } catch (error) {
      this.logger.error(error)
      throw error
    }
  }
}

Effect-TS 方式：

// Effect-TS：声明式依赖 + 类型安全错误处理
export const createSession = Effect.gen(function* () {
  const config = yield* Config.Service    // 自动注入
  const db = yield* Database.Service     // 自动注入
  const bus = yield* EventBus.Service    // 自动注入
  const perm = yield* Permission.Service // 自动注入
  
  yield* perm.check('session.create')    // 类型安全的权限检查
  
  const session = yield* db.insert('sessions', { projectId })
  yield* bus.publish('session.created', session)
  
  return session
})

// 运行时：依赖自动解析，错误自动传播
const result = await runPromise(createSession, {
  layers: [Config.defaultLayer, Database.layer, ...]
})

Effect-TS 的真正价值不在于代码量减少，而在于类型安全的依赖管理和编译时错误检查。 在一个 158K Star 的大型项目中，这种编译时保证可以显著减少运行时错误。

五、多提供商系统：Vercel AI SDK 的统一抽象

OpenCode 的第二个核心创新是**完全的 Provider-Agnostic（提供商无关）**设计。通过 Vercel AI SDK 统一封装，它支持 75+ 个 LLM 提供商：

5.1 提供商抽象层

// packages/opencode/src/provider/provider.ts
import { streamText } from "ai"

// 统一接口：无论底层是 Claude、GPT 还是本地 Ollama
const result = streamText({
  model: provider.getModel(providerID, modelID),
  messages: [...],
  tools: toolRegistry.tools(),
})

// 流式响应：text-delta / reasoning-delta 逐字更新
for await (const chunk of result.textStream) {
  process.stdout.write(chunk)
}

5.2 支持的模型提供商矩阵

5.3 配置系统

OpenCode 的配置采用 JSONC（JSON with Comments）格式，支持项目级和用户级配置：

// .opencode/opencode.jsonc
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "anthropic": {
      "apiKey": "sk-ant-xxx"
    },
    "openai": {
      "apiKey": "sk-xxx"
    }
  },
  "model": {
    "default": "anthropic/claude-sonnet-4-20250514",
    "plan": "anthropic/claude-opus-4-20250514"
  },
  "mcp": {
    "servers": {
      "context7": {
        "url": "https://mcp.context7.com/sse",
        "type": "sse"
      }
    }
  }
}

配置优先级：环境变量 (OPENCODE_*) > 项目配置 (.opencode/config.jsonc) > 用户配置 (~/.opencode/config.jsonc) > 系统配置 (/Library/Application Support/opencode/)

这意味着你可以在一个项目中用 Claude，在另一个项目中用 GPT，在第三个项目中用本地 Ollama——完全不需要重启或重新安装。

5.4 OpenCode Zen：免费模型的杀手锏

OpenCode Zen 是官方提供的免费模型托管服务，目前已提供 GLM-4.7、MiniMax M2.1 等模型，无需 API Key 即可使用。这是 OpenCode 吸引大量开发者的重要原因之一——你可以零成本开始使用 AI 编程助手，再逐步决定是否付费升级到更好的模型。

六、Agent 系统：三种模式的设计哲学

OpenCode 内置三种 Agent，按 Tab 键快速切换：

6.1 Agent 模式分类

6.2 权限系统的设计

每种 Agent 都有独立的权限配置，支持细粒度控制：

// build Agent 的默认权限
{
  "*": "allow",           // 默认允许所有操作
  "doom_loop": "ask",     // 无限循环需要询问
  "read": {
    "*.env": "ask",       // .env 文件需要询问
    "*.env.*": "ask",     // .env.local 等需要询问
  },
  "question": "allow",    // 允许提问
}

// plan Agent 的权限（只读模式）
{
  "*": "deny",            // 默认拒绝所有修改操作
  "read": "allow",        // 允许读取
  "question": "allow",    // 允许提问
  "bash": "ask",          // 执行命令需要询问
}

权限规则支持多层合并（优先级：用户 > Agent > 默认）：

// packages/opencode/src/permission/
Permission.merge(defaults, agentRules, userRules)

plan Agent 的设计哲学值得关注： 它默认拒绝文件修改，执行 Bash 命令前必须经用户确认，是处理不熟悉代码库时的"安全探索模式"，避免意外改动。这在处理大型遗留项目时尤其有用——你可以先用 plan Agent 分析代码结构和改动方案，确认无误后再切换到 build Agent 执行。

6.3 Agent 的内部实现

// packages/opencode/src/agent/agent.ts
export interface AgentConfig {
  name: string
  mode: "primary" | "subagent" | "all"
  permission: PermissionRules
  prompt: string
  steps: number
  temperature?: number
  topP?: number
}

// Agent 调用工具时的权限检查流程
async function executeTool(tool, args, agent) {
  // 1. 检查 Agent 权限
  const permission = Permission.check(agent.permission, tool.name, args)
  if (permission === "deny") throw new PermissionError()
  if (permission === "ask") {
    const confirmed = await askUserConfirm(`允许执行 ${tool.name}?`)
    if (!confirmed) return "cancelled"
  }
  
  // 2. 执行工具
  const result = await tool.execute(args)
  
  // 3. 自动截断过长输出
  return Truncate.output(result, MAX_OUTPUT_LENGTH)
}

七、扩展体系：四层可定制能力

OpenCode 在项目级 .opencode/ 目录下提供四层扩展机制：

7.1 四层扩展架构

7.2 Skills 系统详解

Skills 是 OpenCode 最强大的扩展机制之一，它允许你将领域知识封装为 Markdown 文件，Agent 会根据 description 自动判断何时加载：

---
name: commit
description: Generate git commit message following conventional commits
model: anthropic/claude-sonnet-4-20250514
subtask: true
---

Create a commit message following conventional commits format:
- type(scope): description
- Use imperative mood
- Keep subject line under 72 characters
- Add body for complex changes

## Types
- feat: new feature
- fix: bug fix
- docs: documentation
- style: formatting
- refactor: code restructuring
- test: adding tests
- chore: maintenance

Skills 与 Claude Code Skills 的对比：

7.3 MCP 集成

OpenCode 完整支持 Model Context Protocol，可挂载本地或远程 MCP 服务扩展工具能力：

{
  "mcp": {
    "servers": {
      "context7": {
        "url": "https://mcp.context7.com/sse",
        "type": "sse",
        "auth": { "type": "oauth" }
      },
      "local-db": {
        "command": "node",
        "args": ["./mcp-servers/db-query.js"],
        "type": "stdio"
      },
      "playwright": {
        "command": "npx",
        "args": ["@anthropic-ai/mcp-playwright"],
        "type": "stdio"
      }
    }
  }
}

MCP 类型支持：

7.4 自定义工具

OpenCode 支持用 TypeScript 编写自定义工具，直接注入 Agent 的工具集：

// .opencode/tools/my-tool.ts
import { z } from "zod"

export default {
  description: "Search project documentation",
  args: {
    query: z.string().describe("Search query"),
    limit: z.number().optional().describe("Max results"),
  },
  execute: async (args, ctx) => {
    // ctx 包含当前项目信息、会话状态等
    const results = await searchDocs(args.query, args.limit ?? 5)
    return results.map(r => `${r.title}: ${r.snippet}`).join("\n")
  },
}

八、Event Sourcing：状态同步的工程哲学

OpenCode 的另一个架构亮点是 Event Sourcing 模式——所有状态变更都通过事件流记录和重放，而非直接修改数据库。

8.1 Event Bus 系统

// packages/opencode/src/bus/bus-event.ts
// 事件定义
BusEvent.define("session.error", z.object({
  sessionID: SessionID.zod.optional(),
  error: MessageV2.Assistant.shape.error,
}))

// 发布事件
Bus.publish(Event.Error, { sessionID, error })

// 订阅所有事件
bus.subscribeAll().pipe(
  Stream.runForEach((event) => handleEvent(event))
)

8.2 Sync Event（同步事件）

Sync Event 是 OpenCode 的状态同步核心，具有以下特性：

• 版本化事件：支持事件版本迁移，向后兼容
• 幂等处理：通过序列号检查，防止重复处理
• 事务性保证：事件与状态变更原子绑定
• 可重放：用于状态恢复和多客户端同步

// packages/opencode/src/sync/index.ts
// Sync Event 确保多客户端状态一致
// 当 TUI 客户端和 Web 客户端同时连接时
// 它们通过 Sync Event 保持状态同步

// 客户端 A 修改了文件
syncEvent.publish("file.modified", { path, content })

// 客户端 B 自动收到通知并更新状态
syncEvent.subscribe("file.modified", (event) => {
  updateLocalState(event.path, event.content)
})

Event Sourcing 的工程价值： 当你有 TUI、Web、Desktop 三个客户端同时连接时，它们需要共享同一份状态。传统的"轮询数据库"方式效率低下且容易出现竞态条件。Event Sourcing 通过事件流保证了状态的最终一致性，同时支持事件重放——即使客户端断线重连，也可以通过重放事件恢复到最新状态。

九、LSP 集成：终端中的 IDE 级代码理解

OpenCode 原生集成了 Language Server Protocol（LSP），这是它与 Claude Code 的一个关键差异。

9.1 LSP 的作用

LSP 让 AI 可以像 IDE 一样"理解"代码：

• 跳转到定义：AI 可以追踪函数调用链
• 查找引用：了解一个函数被哪些地方调用
• 获取诊断信息：读取类型错误、警告信息
• 代码补全：基于上下文提供精确建议
• 重构支持：重命名符号、提取方法等

9.2 tree-sitter 的多语言支持

OpenCode 使用 tree-sitter 进行 AST（抽象语法树）解析：

// tree-sitter 支持的语言
const supportedLanguages = [
  "typescript", "javascript", "tsx", "jsx",
  "python", "go", "rust", "java", "kotlin",
  "c", "cpp", "csharp", "swift", "php",
  "ruby", "lua", "bash", "sql", "yaml", "json"
]

// tree-sitter 的核心优势：
// 1. 增量解析：只重新解析变更部分，毫秒级响应
// 2. 错误恢复：即使代码有语法错误，也能给出合理的解析结果
// 3. 多语言支持：一套 API 解析 20+ 种语言

9.3 LSP + AI 的协同工作流

// AI 请求跳转到定义
const definition = await lsp.getDefinition(uri, position)
// AI 获得：文件路径 + 行号 + 符号信息

// AI 请求查找所有引用
const references = await lsp.getReferences(uri, position)
// AI 获得：所有调用该函数的位置列表

// AI 请求诊断信息
const diagnostics = await lsp.getDiagnostics(uri)
// AI 获得：类型错误、警告、建议

这意味着 AI 在编写代码时，可以像一个熟悉项目的老开发者一样——它知道每个函数定义在哪里、被谁调用、有什么类型约束。 这比简单的"读文件"要强大得多。

十、Session 管理：会话分叉与回滚

OpenCode 的 Session 系统支持一些高级功能，这在 AI 编程工具中相当罕见：

10.1 会话核心字段

interface Session {
  id: SessionID      // ULID 格式，时间排序
  slug: string       // 人类可读标识
  projectID: ProjectID  // 所属项目
  parentID?: SessionID  // 父会话（fork 时）
  title: string      // 会话标题
  version: string    // OpenCode 版本
  summary?: {        // 代码变更统计
    filesChanged: number
    linesAdded: number
    linesRemoved: number
  }
  share?: {          // 分享 URL
    url: string
    expiresAt: Date
  }
  revert?: {         // 回滚信息
    commitSHA: string
    revertedAt: Date
  }
}

10.2 会话分叉（Fork）

// 当 AI 的修改方向不对时，你可以分叉会话
// 从当前状态创建一个新的分支，保留原始会话不变

const forkedSession = await session.fork(currentSession.id)
// forkedSession.parentID = currentSession.id
// 原始会话的后续修改不会影响分叉会话

// 这就像 Git 的分支——你可以在多个方向同时探索
// 找到正确方向后再合并或切换

10.3 会话回滚

// 如果 AI 的修改引入了 Bug，可以一键回滚
await session.revert(sessionId, {
  commitSHA: "abc123",  // 回滚到指定提交
})
// 所有文件变更会被撤销，会话状态恢复到该提交时的状态

会话分叉和回滚的设计，本质上是将 Git 的分支和回滚能力引入了 AI 编程工作流。 这让你可以大胆尝试 AI 的建议——即使方向错了，也能安全回退。

十一、多平台支持：从终端到桌面

OpenCode 的多平台支持不是简单的"移植"，而是基于解耦架构的自然延伸：

11.1 四种形态

11.2 Desktop App（Beta）

# macOS Apple Silicon
opencode-desktop-darwin-aarch64.dmg

# macOS Intel
opencode-desktop-darwin-x64.dmg

# Windows
opencode-desktop-windows-x64.exe

# Linux
.opencode-desktop-linux-x64.deb / .rpm / AppImage

11.3 安装方式

# 一键脚本（macOS / Linux）
curl -fsSL https://opencode.ai/install | bash

# Homebrew（推荐，始终最新）
brew install anomalyco/tap/opencode

# npm（全平台）
npm i -g opencode-ai@latest

# Scoop（Windows）
scoop install opencode

# Nix（NixOS / 任意）
nix run nixpkgs#opencode

# mise（全平台版本管理器）
mise use -g opencode

十二、性能优化与基准对比

12.1 Bun 运行时的性能优势

OpenCode 选择 Bun 而非 Node.js，带来了显著的性能提升：

12.2 SolidJS 的 TUI 渲染性能

SolidJS 的细粒度响应式系统让 TUI 界面的更新效率远超 React：

// SolidJS：细粒度更新，只重绘变化的部分
const [count, setCount] = createSignal(0)

// React：整个组件树重新渲染
// SolidJS：只有 count 的 DOM 节点更新
<div>{count()}</div>

// 在 TUI 场景中，这意味着：
// - 工具调用结果流式显示时，不会卡顿
// - 大量输出滚动时，帧率保持稳定
// - 多 Agent 同时输出时，界面依然流畅

12.3 实测性能数据

基于社区反馈和基准测试：

这些数据来自社区基准测试，具体数值会因硬件和配置不同而有差异。

十三、与竞品的全面对比

13.1 六大终端 AI 编码 Agent 横评

13.2 OpenCode 的差异化优势

1. 彻底的模型无关性

• 不绑定任何厂商，75+ 提供商随时切换
• 支持本地模型（Ollama、LM Studio），代码永不离开你的机器
• OpenCode Zen 提供免费模型，零成本入门

2. 客户端/服务器解耦

• TUI 只是客户端之一，未来可扩展到手机、平板、Web
• mDNS 自动发现，局域网内即插即用
• 远程驱动架构，手机发指令电脑执行

3. 四层可定制扩展

• Skills 封装领域知识
• Custom Commands 定义工作流
• Custom Agents 定制行为
• Custom Tools 用 TypeScript 编写

4. 原生 LSP 集成

• AI 可以像 IDE 一样理解代码
• 跳转定义、查找引用、类型检查
• tree-sitter 多语言 AST 解析

5. 会话分叉与回滚

• Git 式的分支探索
• 安全回退，大胆尝试
• 多方向并行开发

十四、实战：从零搭建 OpenCode 开发环境

14.1 安装与配置

# 1. 安装 OpenCode
curl -fsSL https://opencode.ai/install | bash

# 2. 进入项目目录
cd your-project

# 3. 启动 OpenCode
opencode
# 首次启动会自动初始化，生成 AGENTS.md

14.2 连接模型

# 方式 1：使用 OpenCode Zen（免费）
# 在 TUI 中输入
/connect zen

# 方式 2：使用 Anthropic
/opencode config init
# 编辑 .opencode/opencode.jsonc
# 添加 Anthropic API Key

# 方式 3：使用本地 Ollama
/opencode config init
# 配置 OpenAI-Compatible 接口

14.3 日常使用流程

# 1. 启动
cd your-project && opencode

# 2. 切换 Agent
# Tab: build → plan → general

# 3. 对话
# "帮我重构 UserService 类，提取公共方法"
# "这个 Bug 是什么原因？如何修复？"
# "帮我写单元测试"

# 4. 使用命令
/commit          # 生成 git commit message
/spellcheck      # 检查拼写
/general         # 调用子 Agent 进行复杂搜索

14.4 高级配置示例

// .opencode/opencode.jsonc
{
  "$schema": "https://opencode.ai/config.json",
  
  // 多模型提供商
  "provider": {
    "anthropic": { "apiKey": "sk-ant-xxx" },
    "openai": { "apiKey": "sk-xxx" },
    "groq": { "apiKey": "gsk_xxx" }
  },
  
  // 不同 Agent 使用不同模型
  "model": {
    "default": "anthropic/claude-sonnet-4-20250514",
    "plan": "anthropic/claude-opus-4-20250514",
    "general": "groq/llama-3.3-70b-versatile"
  },
  
  // MCP 服务
  "mcp": {
    "servers": {
      "context7": {
        "url": "https://mcp.context7.com/sse",
        "type": "sse"
      }
    }
  },
  
  // 自定义工具
  "tools": {
    "database-query": "./tools/db-query.ts",
    "api-tester": "./tools/api-tester.ts"
  }
}

十五、总结与展望

OpenCode 代表了 AI 编程工具的另一种可能：不靠生态锁定，靠开放赢得开发者。

核心价值总结

未来展望

1. 远程驱动成熟化：手机端指令 → 电脑端执行的场景将更加流畅
2. 多 Agent 协作：orchestrator、architect、executor、reviewer 等角色将更加完善
3. 边缘计算：结合 Bun + Hono 的轻量级架构，OpenCode 有望跑在路由器、IoT 设备上
4. 生态扩展：Skills 和 MCP 的生态将更加丰富，覆盖更多开发场景

在 Claude Code 凭借 Anthropic 光环席卷市场之时，OpenCode 用"你可以换任何模型、自己托管、自己改代码"的彻底开放性，吸引了数以万计的开发者。

对于追求掌控感与灵活性的工程师，OpenCode 不仅是一个工具——它是对"AI 编程应该是什么样子"这个问题的一个有力回答。

参考资料：

• OpenCode 官方网站 — opencode.ai
• OpenCode GitHub 仓库 — anomalyco/opencode
• OpenCode 官方文档 — opencode.ai/docs
• OpenCode Zen 模型服务 — opencode.ai/zen
• Model Context Protocol 规范 — modelcontextprotocol.io
• Vercel AI SDK 文档 — sdk.vercel.ai
• Effect-TS 文档 — effect.website