提供商

在 OpenCode 中使用任意 LLM provider。

OpenCode 使用 AI SDK (opens in a new tab) 和 Models.dev (opens in a new tab)，支持 75+ 种 LLM provider，并支持运行本地模型。

要添加一个 provider，你需要：

使用 /connect 命令为该 provider 添加 API key。
在你的 OpenCode 配置中配置该 provider。

凭据

当你用 /connect 命令添加某个 provider 的 API key 时，它们会存储在 ~/.local/share/opencode/auth.json 中。

配置

你可以通过 OpenCode 配置中的 provider 部分来自定义各个 provider。

基础 URL

你可以通过设置 baseURL 选项来自定义任意 provider 的 base URL。这在使用代理服务或自定义端点时很有用。

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "anthropic": {
      "options": {
        "baseURL": "https://api.anthropic.com/v1"
      }
    }
  }
}

隐藏模型

你可以使用 blacklist 选项，将某个 provider 的特定模型从 /models 选择器中隐藏。当某个 provider 暴露了你不想使用或选择的模型时，这很有用。

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "anthropic": {
      "blacklist": ["claude-opus-4-20250514"]
    }
  }
}

与之相反的 whitelist 选项会隐藏除列表中模型之外的所有模型。

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "anthropic": {
      "whitelist": ["claude-sonnet-4-20250514"]
    }
  }
}

这两个选项都接受一个模型 ID 数组——与 /models 选择器中显示的 ID 相同。

blacklist 会将列出的模型从选择器中移除。
whitelist 只保留列出的模型，隐藏其余的。
你可以将两者结合使用：先用 whitelist 缩小范围，再用 blacklist 从中移除条目。

OpenCode Zen

OpenCode Zen 是由 OpenCode 团队提供的一份模型清单，这些模型已经过测试并验证可与 OpenCode 良好配合。了解更多。

Tip: 如果你是新手，我们推荐从 OpenCode Zen 开始。

在 TUI 中运行 /connect 命令，选择 OpenCode Zen，然后前往 opencode.ai/auth (opens in a new tab)。
```
/connect
```
登录、填写账单信息，并复制你的 API key。
粘贴你的 API key。
```
┌ API key
│
│
└ enter
```
在 TUI 中运行 /models 查看我们推荐的模型列表。
```
/models
```

它的工作方式与 OpenCode 中的其他 provider 完全一样，是否使用完全可选。

提供商目录

我们来详细看看其中一些 provider。如果你想把某个 provider 添加到这个列表中，欢迎提交 PR。

Note: 没看到你要找的 provider？提交一个 PR 吧。

302.AI

前往 302.AI 控制台 (opens in a new tab)，创建账号，并生成一个 API key。
运行 /connect 命令并搜索 302.AI。
```
/connect
```
输入你的 302.AI API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型。
```
/models
```

Amazon Bedrock

在 OpenCode 中使用 Amazon Bedrock：

前往 Amazon Bedrock 控制台中的 Model catalog，申请你想使用的模型的访问权限。

Tip: 你需要在 Amazon Bedrock 中拥有你想使用的模型的访问权限。
使用以下方法之一配置身份验证：

环境变量（快速开始）

在运行 opencode 时设置以下环境变量之一：
```
# Option 1: Using AWS access keys
AWS_ACCESS_KEY_ID=XXX AWS_SECRET_ACCESS_KEY=YYY opencode
 
# Option 2: Using named AWS profile
AWS_PROFILE=my-profile opencode
 
# Option 3: Using Bedrock bearer token
AWS_BEARER_TOKEN_BEDROCK=XXX opencode
```
或者将它们添加到你的 bash profile 中：
~/.bash_profile
```
export AWS_PROFILE=my-dev-profile
export AWS_REGION=us-east-1
```
配置文件（推荐）

对于针对特定项目或需要持久化的配置，使用 opencode.json：
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "amazon-bedrock": {
      "options": {
        "region": "us-east-1",
        "profile": "my-aws-profile"
      }
    }
  }
}
```
可用选项：
- region - AWS region（例如 us-east-1 、 eu-west-1 ）
- profile - 来自 ~/.aws/credentials 的 AWS 命名 profile
- endpoint - 用于 VPC 端点的自定义端点 URL（通用 baseURL 选项的别名）
Tip: 配置文件中的选项优先级高于环境变量。

进阶：VPC 端点

如果你为 Bedrock 使用 VPC 端点：
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "amazon-bedrock": {
      "options": {
        "region": "us-east-1",
        "profile": "production",
        "endpoint": "https://bedrock-runtime.us-east-1.vpce-xxxxx.amazonaws.com"
      }
    }
  }
}
```
Note: endpoint 选项是通用 baseURL 选项的别名，使用的是 AWS 专用术语。如果同时指定了 endpoint 和 baseURL，则 endpoint 优先。

身份验证方法
- AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY ：在 AWS 控制台中创建一个 IAM 用户并生成 access key
- AWS_PROFILE ：使用来自 ~/.aws/credentials 的命名 profile。先用 aws configure --profile my-profile 或 aws sso login 进行配置
- AWS_BEARER_TOKEN_BEDROCK ：从 Amazon Bedrock 控制台生成长期 API key
- AWS_WEB_IDENTITY_TOKEN_FILE / AWS_ROLE_ARN ：用于 EKS IRSA（IAM Roles for Service Accounts）或其他带 OIDC 联合身份的 Kubernetes 环境。在使用 service account 注解时，这些环境变量会由 Kubernetes 自动注入。
身份验证优先级

Amazon Bedrock 使用以下身份验证优先级：
1. Bearer Token - AWS_BEARER_TOKEN_BEDROCK 环境变量，或来自 /connect 命令的 token
2. AWS 凭证链 - profile、access key、共享凭证、IAM 角色、Web Identity Token（EKS IRSA）、实例元数据
Note: 当设置了 bearer token（通过 /connect 或 AWS_BEARER_TOKEN_BEDROCK）时，它的优先级高于所有 AWS 凭证方法，包括已配置的 profile。
运行 /models 命令来选择你想使用的模型。
```
/models
```

Note: 对于自定义推理 profile，请在 key 中使用模型和 provider 名称，并将 id 属性设置为该 arn。这能确保缓存正确。

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "amazon-bedrock": {
      // ...
      "models": {
        "anthropic-claude-sonnet-4.5": {
          "id": "arn:aws:bedrock:us-east-1:xxx:application-inference-profile/yyy"
        }
      }
    }
  }
}

Anthropic

注册完成后，运行 /connect 命令并选择 Anthropic。
```
/connect
```
在这里你可以选择 Claude Pro/Max 选项，它会打开你的浏览器并要求你进行身份验证。
```
┌ Select auth method
│
│ Manually enter API Key
└
```
现在当你使用 /models 命令时，所有 Anthropic 模型都应该可用了。
```
/models
```

有一些插件可以让你在 OpenCode 中使用你的 Claude Pro/Max 模型。Anthropic 明确禁止这种做法。

早期版本的 OpenCode 曾捆绑这些插件，但从 1.3.0 起不再如此。

其他公司在开发者工具上支持自由选择——你可以在 OpenCode 中零配置使用以下订阅：

ChatGPT Plus
Github Copilot
Gitlab Duo

Atomic Chat

你可以配置 opencode 通过 Atomic Chat (opens in a new tab) 使用本地模型，它是一个桌面应用，在一个 OpenAI 兼容的 API 服务器（默认端点 http://127.0.0.1:1337/v1）后面运行本地 LLM。

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "atomic-chat": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Atomic Chat (local)",
      "options": {
        "baseURL": "http://127.0.0.1:1337/v1"
      },
      "models": {
        "<your-model-id>": {
          "name": "<your-model-name>"
        }
      }
    }
  }
}

在这个例子中：

atomic-chat 是自定义的 provider ID。可以是你想要的任意字符串。
npm 指定该 provider 使用的包。这里使用 @ai-sdk/openai-compatible，适用于任何 OpenAI 兼容的 API。
name 是 provider 在 UI 中的显示名称。
options.baseURL 是本地服务器的端点。请修改 host 和端口以匹配你的 Atomic Chat 设置。
models 是模型 ID 到其显示名称的映射。每个 ID 必须与 GET /v1/models 返回的 id 匹配——运行 curl http://127.0.0.1:1337/v1/models 可列出 Atomic Chat 中当前已加载的 id。

Tip: 如果工具调用效果不佳，请选择一个对工具调用支持较强的已加载模型（例如 Qwen-Coder 或 DeepSeek-Coder 变体）。

Azure OpenAI

Note: 如果你遇到 "I'm sorry, but I cannot assist with that request" 错误，请尝试在你的 Azure 资源中把内容过滤器从 DefaultV2 改为 Default。

前往 Azure portal (opens in a new tab) 并创建一个 Azure OpenAI 资源。你需要：
- Resource name ：这会成为你的 API 端点的一部分（ https://RESOURCE_NAME.openai.azure.com/ ）
- API key ：来自你资源的 KEY 1 或 KEY 2
前往 Azure AI Foundry (opens in a new tab) 并部署一个模型。

Note: 部署名称必须与模型名称匹配，opencode 才能正常工作。
运行 /connect 命令并搜索 Azure。
```
/connect
```
输入你的 API key。
```
┌ API key
│
│
└ enter
```
将你的资源名称设置为环境变量：
```
AZURE_RESOURCE_NAME=XXX opencode
```
或者将其添加到你的 bash profile 中：
~/.bash_profile
```
export AZURE_RESOURCE_NAME=XXX
```
运行 /models 命令来选择你部署的模型。
```
/models
```

Microsoft Entra ID (Azure CLI)

你可以使用 Azure CLI 会话代替 API key。安装 Azure CLI (opens in a new tab)，运行 az login，然后运行 /connect，选择 Azure 和 Microsoft Entra ID (Azure CLI)。按提示输入 Azure 资源名称。资源属于其他租户时，请使用 az login --tenant TENANT_ID。

在 Azure portal (opens in a new tab) 或 Microsoft Foundry (opens in a new tab) 中打开 Azure OpenAI 或 Foundry 资源即可找到资源名称。它也是 endpoint 的第一部分，例如 https://my-models.openai.azure.com/ 或 https://my-models.services.ai.azure.com/ 中的 my-models。如果你的身份可以列出资源，也可使用以下命令查看名称和资源组：

az cognitiveservices account list \
  --query "[].{name:name,resourceGroup:resourceGroup}" \
  --output table

OpenCode 不会查询 Azure 管理 API，也不会自动发现部署。请选择模型目录中名称与部署匹配的模型，或显式配置部署名称：

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "azure": {
      "models": {
        "gpt-5-mini": {
          "id": "gpt-production"
        }
      }
    }
  }
}

为身份分配部署所需的推理角色：Azure OpenAI 模型使用 Cognitive Services OpenAI User，其他 Foundry 模型使用 Cognitive Services User。OpenCode 会通过 Azure CLI 刷新 access token，包括早于 2.54.0 的版本；仅在 CLI 会话过期时才需重新登录。

Azure Cognitive Services

前往 Azure portal (opens in a new tab) 并创建一个 Azure OpenAI 资源。你需要：
- Resource name ：这会成为你的 API 端点的一部分（ https://AZURE_COGNITIVE_SERVICES_RESOURCE_NAME.cognitiveservices.azure.com/ ）
- API key ：来自你资源的 KEY 1 或 KEY 2
前往 Azure AI Foundry (opens in a new tab) 并部署一个模型。

Note: 部署名称必须与模型名称匹配，opencode 才能正常工作。
运行 /connect 命令并搜索 Azure Cognitive Services。
```
/connect
```
输入你的 API key。
```
┌ API key
│
│
└ enter
```
将你的资源名称设置为环境变量：
```
AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
```
或者将其添加到你的 bash profile 中：
~/.bash_profile
```
export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX
```
运行 /models 命令来选择你部署的模型。
```
/models
```

Baseten

前往 Baseten (opens in a new tab)，创建账号，并生成一个 API key。
运行 /connect 命令并搜索 Baseten。
```
/connect
```
输入你的 Baseten API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型。
```
/models
```

Cerebras

前往 Cerebras 控制台 (opens in a new tab)，创建账号，并生成一个 API key。
运行 /connect 命令并搜索 Cerebras。
```
/connect
```
输入你的 Cerebras API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型，例如 Qwen 3 Coder 480B。
```
/models
```

Cloudflare AI Gateway

Cloudflare AI Gateway 让你能通过统一端点访问来自 OpenAI、Anthropic、Workers AI 等的模型。借助 Unified Billing (opens in a new tab)，你无需为每个 provider 分别准备 API key。

前往 Cloudflare 仪表盘 (opens in a new tab)，导航到 AI > AI Gateway，并创建一个新的 gateway。记下你的 Account ID 和 Gateway ID。
运行 /connect 命令并搜索 Cloudflare AI Gateway。
```
/connect
```

在提示时输入你的 Account ID。

┌ Enter your Cloudflare Account ID
│
│
└ enter

在提示时输入你的 Gateway ID。

┌ Enter your Cloudflare AI Gateway ID
│
│
└ enter

输入你的 Cloudflare API token。
```
┌ Gateway API token
│
│
└ enter
```

运行 /models 命令来选择一个模型。

/models

你也可以通过 opencode 配置添加模型。

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "cloudflare-ai-gateway": {
      "models": {
        "openai/gpt-4o": {},
        "anthropic/claude-sonnet-4": {}
      }
    }
  }
}

或者，你可以设置环境变量来代替使用 /connect。

~/.bash_profile

export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
export CLOUDFLARE_GATEWAY_ID=your-gateway-id
export CLOUDFLARE_API_TOKEN=your-api-token

Cloudflare Workers AI

Cloudflare Workers AI 让你能直接通过 REST API 在 Cloudflare 的全球网络上运行 AI 模型，对于受支持的模型无需单独的 provider 账号。

前往 Cloudflare 仪表盘 (opens in a new tab)，导航到 Workers AI，并选择 Use REST API 来获取你的 Account ID 并创建一个 API token。
运行 /connect 命令并搜索 Cloudflare Workers AI。
```
/connect
```

在提示时输入你的 Account ID。

┌ Enter your Cloudflare Account ID
│
│
└ enter

输入你的 Cloudflare API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型。
```
/models
```
或者，你可以设置环境变量来代替使用 /connect。
~/.bash_profile
```
export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
export CLOUDFLARE_API_KEY=your-api-token
```

Cortecs

前往 Cortecs 控制台 (opens in a new tab)，创建账号，并生成一个 API key。
运行 /connect 命令并搜索 Cortecs。
```
/connect
```
输入你的 Cortecs API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型，例如 Kimi K2 Instruct。
```
/models
```

DeepSeek

前往 DeepSeek 控制台 (opens in a new tab)，创建账号，并点击 Create new API key。
运行 /connect 命令并搜索 DeepSeek。
```
/connect
```
输入你的 DeepSeek API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个 DeepSeek 模型，例如 DeepSeek V4 Pro。
```
/models
```

Deep Infra

前往 Deep Infra 仪表盘 (opens in a new tab)，创建账号，并生成一个 API key。
运行 /connect 命令并搜索 Deep Infra。
```
/connect
```
输入你的 Deep Infra API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型。
```
/models
```

DigitalOcean

DigitalOcean 的 Inference Engine (opens in a new tab) 提供对 GPT-OSS、Llama、Qwen 和 DeepSeek 等开源模型的访问，外加自定义的 Inference Routers (opens in a new tab)，可将每个请求路由到针对某项任务最便宜、最快或最合适的模型。

OpenCode 支持两种身份验证方法：

OAuth（推荐） —— 登录你的 DigitalOcean 账号；OpenCode 会直接使用你的 DigitalOcean API token 进行推理，并发现你的 Inference Routers。
Model Access Key —— 从 DigitalOcean 控制台粘贴一个现有的 key。

OAuth（推荐）

运行 /connect 命令并搜索 DigitalOcean。
```
/connect
```

选择 Login with DigitalOcean。

┌ Select auth method
│
│ Login with DigitalOcean
│ Paste Model Access Key
└

你的浏览器会打开以授权 OpenCode。登录并批准。

Note: OpenCode 会请求 genai:read 和 inference:query 这两个 OAuth scope。你的 DigitalOcean API token 会直接用于推理——不会创建单独的 Model Access Key。

Note: Inference Routers 只有在完成 OAuth 后才会出现在模型选择器中。手动粘贴 Model Access Key 不会发现 router。
运行 /models 命令。你的 Inference Routers 会以 router: 的格式出现在模型选择中。
```
/models
```
要获取新创建的 Inference Routers，请重新运行 /connect 并再次选择 DigitalOcean。

使用 Model Access Key

如果你更愿意直接粘贴一个 key：

前往 DigitalOcean 控制台 (opens in a new tab) Inference 部分的 Manage 页面，并创建一个新的 key。
运行 /connect 命令并选择 DigitalOcean，然后选择 Paste Model Access Key。
```
┌ Enter your DigitalOcean Model Access Key
│
│
└ enter
```
Note: 使用此方法不会自动发现 Inference Routers。要在模型选择器中显示它们，请改用 OAuth 登录。
运行 /models 命令来选择一个模型。
```
/models
```

环境变量

或者，将你的 Model Access Key 设置为环境变量。

export DIGITALOCEAN_ACCESS_TOKEN=your-model-access-key

推理路由器

Inference Routers 让你能在多个模型之间定义路由策略——根据任务为每个请求挑选最便宜、最快或最合适的模型。OAuth 后，OpenCode 会在模型选择器中将每个 router 显示为 router:<router-name>。

选择一个 router 模型可以无缝替换任何其他模型——OpenCode 转发你的请求，DigitalOcean 根据你的 router 策略挑选底层模型。了解更多关于 Inference Routers (opens in a new tab) 的信息。

Eden AI

Eden AI (opens in a new tab) 是一家位于欧盟的网关服务，通过统一的 OpenAI 兼容 API 提供多个厂商的模型。需要在欧盟内执行推理的团队可以使用其独立的欧盟端点。

前往 Eden AI 平台 (opens in a new tab) 创建账户并生成 API key。
运行 /connect 命令并搜索 Eden AI。
```
/connect
```
输入你的 Eden AI API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令，选择 Mistral Large 3 或 Claude Sonnet 5 等模型。
```
/models
```
Eden AI 的模型 ID 本身采用 vendor/model 格式，因此完整引用包含三段，例如 edenai/anthropic/claude-sonnet-5。
如果要使用 Eden AI 的欧盟网关，请设置其基础 URL。
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "edenai": {
      "options": {
        "baseURL": "https://api.eu.edenai.run/v3"
      }
    }
  }
}
```
默认地址为 https://api.edenai.run/v3，上述配置将全球端点替换为欧盟端点。欧盟端点只提供模型目录中在欧盟可用的部分模型，因此第 4 步选择的模型不一定能通过该端点访问。

FrogBot

前往 FrogBot 仪表盘 (opens in a new tab)，创建账号，并生成一个 API key。
运行 /connect 命令并搜索 FrogBot。
```
/connect
```
输入你的 FrogBot API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型。
```
/models
```

Fireworks AI

前往 Fireworks AI 控制台 (opens in a new tab)，创建账号，并点击 Create API Key。
运行 /connect 命令并搜索 Fireworks AI。
```
/connect
```
输入你的 Fireworks AI API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型，例如 Kimi K2 Instruct。
```
/models
```

GitLab Duo

Caution: OpenCode 中的 GitLab Duo 支持仍处于实验阶段。功能、配置和行为在未来版本中可能会变化。

OpenCode 与 GitLab Duo Agent Platform (opens in a new tab) 集成，提供由 AI 驱动、具备原生工具调用能力的 agentic 聊天。

Note: GitLab Duo Agent Platform 需要 Premium 或 Ultimate GitLab 订阅。它在 GitLab.com 和 GitLab Self-Managed 上可用。完整要求请参阅 GitLab Duo Agent Platform prerequisites (opens in a new tab)。

运行 /connect 命令并选择 GitLab。
```
/connect
```
选择你的身份验证方法：
```
┌ Select auth method
│
│ OAuth (Recommended)
│ Personal Access Token
└
```
使用 OAuth（推荐）

选择 OAuth，你的浏览器将打开以进行授权。

使用 Personal Access Token
1. 前往 GitLab User Settings > Access Tokens (opens in a new tab)
2. 点击 Add new token
3. Name：OpenCode ，Scopes：api
4. 复制该 token（以 glpat- 开头）
5. 在终端中输入它
运行 /models 命令查看可用模型。
```
/models
```
有三个基于 Claude 的模型可用：
- duo-chat-haiku-4-5（默认）- 快速响应，适合快速任务
- duo-chat-sonnet-4-5 - 性能均衡，适合大多数工作流
- duo-chat-opus-4-5 - 能力最强，适合复杂分析

Note: 如果你不想在 opencode 的 auth 存储中保存 token，你也可以指定 'GITLAB_TOKEN' 环境变量。

自托管 GitLab

Note: OpenCode 会为某些 AI 任务（例如生成会话标题）使用一个小模型。它默认配置为使用由 Zen 托管的 gpt-5-nano。要将 OpenCode 锁定为只使用你自己的 GitLab 托管实例，请将以下内容添加到你的 opencode.json 文件中。同时也建议禁用会话共享。
{
  "$schema": "https://opencode.ai/config.json",
  "small_model": "gitlab/duo-chat-haiku-4-5",
  "share": "disabled"
}

对于自托管的 GitLab 实例：

export GITLAB_INSTANCE_URL=https://gitlab.company.com
export GITLAB_TOKEN=glpat-...

如果你的实例运行一个自定义的 AI Gateway：

GITLAB_AI_GATEWAY_URL=https://ai-gateway.company.com

或者添加到你的 bash profile：

~/.bash_profile

export GITLAB_INSTANCE_URL=https://gitlab.company.com
export GITLAB_AI_GATEWAY_URL=https://ai-gateway.company.com
export GITLAB_TOKEN=glpat-...

Note: 你的 GitLab 管理员必须：

为该用户、群组或实例 Turn on GitLab Duo (opens in a new tab)

Turn on the Agent Platform (opens in a new tab)（GitLab 18.8+）或 enable beta and experimental features (opens in a new tab)（GitLab 18.7 及更早版本）

对于 Self-Managed，configure your instance (opens in a new tab)

用于自托管实例的 OAuth

为了让 OAuth 在你的自托管实例上工作，你需要创建一个新的应用（Settings → Applications），其回调 URL 为 http://127.0.0.1:8080/callback，并具有以下 scope：

api（代表你访问 API）
read_user（读取你的个人信息）
read_repository（允许对仓库进行只读访问）

然后将应用 ID 暴露为环境变量：

export GITLAB_OAUTH_CLIENT_ID=your_application_id_here

更多文档参见 opencode-gitlab-auth (opens in a new tab) 主页。

配置

通过 opencode.json 自定义：

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "gitlab": {
      "options": {
        "instanceUrl": "https://gitlab.com"
      }
    }
  }
}

GitLab Duo Agent Platform（DAP）工作流模型

DAP workflow 模型提供一条替代的执行路径，它将工具调用通过 GitLab 的 Duo Workflow Service (DWS) 路由，而不是走标准的 agentic 聊天。当选择 duo-workflow-* 模型时，OpenCode 将会：

从你的 GitLab namespace 发现可用模型
如果有多个可用模型，显示一个选择器
将选定的模型缓存到磁盘，以便后续启动更快
通过 OpenCode 的受权限门控的工具系统路由工具执行请求

可用的 DAP workflow 模型遵循 duo-workflow-* 命名约定，并从你的 GitLab 实例动态发现。

GitLab API Tools（可选，但强烈推荐）

要访问 GitLab 工具（merge request、issue、pipeline、CI/CD 等）：

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "plugin": ["opencode-gitlab-plugin"]
}

此插件提供全面的 GitLab 仓库管理能力，包括 MR 评审、issue 跟踪、pipeline 监控等。

GitHub Copilot

在 opencode 中使用你的 GitHub Copilot 订阅：

Note: 某些模型可能需要 Pro+ 订阅 (opens in a new tab) 才能使用。

运行 /connect 命令并搜索 GitHub Copilot。
```
/connect
```

导航到 github.com/login/device (opens in a new tab) 并输入该代码。

┌ Login with GitHub Copilot
│
│ https://github.com/login/device
│
│ Enter code: 8F43-6FCF
│
└ Waiting for authorization...

现在运行 /models 命令来选择你想使用的模型。
```
/models
```

GMI Cloud

在 OpenCode 中使用 GMI Cloud：

前往 GMI Cloud 控制台 (opens in a new tab) 创建一个 API key。你也可以查看 API 参考文档 (opens in a new tab) 了解端点详情。
运行 /connect 命令并搜索 GMI Cloud。
```
/connect
```
输入你的 GMI Cloud API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择你想使用的模型。
```
/models
```

Google Vertex AI

在 OpenCode 中使用 Google Vertex AI：

前往 Google Cloud Console 中的 Model Garden，查看你所在 region 可用的模型。

Note: 你需要有一个启用了 Vertex AI API 的 Google Cloud 项目。
设置所需的环境变量：
- GOOGLE_CLOUD_PROJECT ：你的 Google Cloud 项目 ID
- VERTEX_LOCATION （可选）：Vertex AI 的 region（默认为 global ）
- 身份验证（任选其一）：
  - GOOGLE_APPLICATION_CREDENTIALS ：你的 service account JSON key 文件的路径
  - 使用 gcloud CLI 进行身份验证：gcloud auth application-default login
在运行 opencode 时设置它们。
```
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id opencode
```
或者将它们添加到你的 bash profile。
~/.bash_profile
```
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
export GOOGLE_CLOUD_PROJECT=your-project-id
export VERTEX_LOCATION=global
```

Tip: global region 可以提升可用性并减少错误，且不产生额外费用。如果有数据驻留要求，请使用区域端点（例如 us-central1）。了解更多 (opens in a new tab)

运行 /models 命令来选择你想使用的模型。
```
/models
```

Groq

前往 Groq 控制台 (opens in a new tab)，点击 Create API Key，并复制该 key。
运行 /connect 命令并搜索 Groq。
```
/connect
```
输入该 provider 的 API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择你想要的那一个。
```
/models
```

Hugging Face

Hugging Face Inference Providers (opens in a new tab) 提供对由 17+ 个 provider 支持的开源模型的访问。

前往 Hugging Face settings (opens in a new tab) 创建一个有权限调用 Inference Providers 的 token。
运行 /connect 命令并搜索 Hugging Face。
```
/connect
```
输入你的 Hugging Face token。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型，例如 Kimi-K2-Instruct 或 GLM-4.6。
```
/models
```

Helicone

Helicone (opens in a new tab) 是一个 LLM 可观测性平台，为你的 AI 应用提供日志、监控和分析。Helicone AI Gateway 会根据模型自动将你的请求路由到合适的 provider。

前往 Helicone (opens in a new tab)，创建账号，并从你的仪表盘生成一个 API key。
运行 /connect 命令并搜索 Helicone。
```
/connect
```
输入你的 Helicone API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型。
```
/models
```

要了解更多 provider 以及缓存、限流等进阶功能，请查看 Helicone 文档 (opens in a new tab)。

可选配置

如果你看到 Helicone 提供的某项功能或某个模型没有通过 opencode 自动配置，你随时可以自己配置它。

这里是 Helicone 的模型目录 (opens in a new tab)，你需要用它来获取你想添加的模型的 ID。

~/.config/opencode/opencode.jsonc

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "helicone": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Helicone",
      "options": {
        "baseURL": "https://ai-gateway.helicone.ai",
      },
      "models": {
        "gpt-4o": {
          // Model ID (from Helicone's model directory page)
          "name": "GPT-4o", // Your own custom name for the model
        },
        "claude-sonnet-4-20250514": {
          "name": "Claude Sonnet 4",
        },
      },
    },
  },
}

自定义 Headers

Helicone 支持自定义 header，用于缓存、用户跟踪和会话管理等功能。使用 options.headers 将它们添加到你的 provider 配置中：

~/.config/opencode/opencode.jsonc

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "helicone": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Helicone",
      "options": {
        "baseURL": "https://ai-gateway.helicone.ai",
        "headers": {
          "Helicone-Cache-Enabled": "true",
          "Helicone-User-Id": "opencode",
        },
      },
    },
  },
}

会话跟踪

Helicone 的 Sessions (opens in a new tab) 功能让你能将相关的 LLM 请求分组到一起。使用 opencode-helicone-session (opens in a new tab) 插件，可以自动将每次 OpenCode 对话作为一个会话记录到 Helicone 中。

npm install -g opencode-helicone-session

将它添加到你的配置中。

opencode.json

{
  "plugin": ["opencode-helicone-session"]
}

该插件会向你的请求中注入 Helicone-Session-Id 和 Helicone-Session-Name header。在 Helicone 的 Sessions 页面中，你会看到每次 OpenCode 对话被列为一个单独的会话。

常见的 Helicone header

Header	说明
`Helicone-Cache-Enabled`	启用响应缓存（`true`/`false`）
`Helicone-User-Id`	按用户跟踪指标
`Helicone-Property-[Name]`	添加自定义属性（例如 `Helicone-Property-Environment`）
`Helicone-Prompt-Id`	将请求与 prompt 版本关联

所有可用的 header 请参阅 Helicone Header Directory (opens in a new tab)。

llama.cpp

你可以配置 opencode 通过 llama.cpp (opens in a new tab) 的 llama-server 工具使用本地模型。

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llama.cpp": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "llama-server (local)",
      "options": {
        "baseURL": "http://127.0.0.1:8080/v1"
      },
      "models": {
        "qwen3-coder:a3b": {
          "name": "Qwen3-Coder: a3b-30b (local)",
          "limit": {
            "context": 128000,
            "output": 65536
          }
        }
      }
    }
  }
}

在这个例子中：

llama.cpp 是自定义的 provider ID。可以是你想要的任意字符串。
npm 指定该 provider 使用的包。这里使用 @ai-sdk/openai-compatible，适用于任何 OpenAI 兼容的 API。
name 是 provider 在 UI 中的显示名称。
options.baseURL 是本地服务器的端点。
models 是模型 ID 到其配置的映射。模型名称会显示在模型选择列表中。

IO.NET

IO.NET 提供针对各种用例优化的 17 个模型：

前往 IO.NET 控制台 (opens in a new tab)，创建账号，并生成一个 API key。
运行 /connect 命令并搜索 IO.NET。
```
/connect
```
输入你的 IO.NET API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型。
```
/models
```

LM Studio

你可以配置 opencode 通过 LM Studio 使用本地模型。

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "lmstudio": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "LM Studio (local)",
      "options": {
        "baseURL": "http://127.0.0.1:1234/v1"
      },
      "models": {
        "google/gemma-3n-e4b": {
          "name": "Gemma 3n-e4b (local)"
        }
      }
    }
  }
}

在这个例子中：

lmstudio 是自定义的 provider ID。可以是你想要的任意字符串。
npm 指定该 provider 使用的包。这里使用 @ai-sdk/openai-compatible，适用于任何 OpenAI 兼容的 API。
name 是 provider 在 UI 中的显示名称。
options.baseURL 是本地服务器的端点。
models 是模型 ID 到其配置的映射。模型名称会显示在模型选择列表中。

Moonshot AI

使用来自 Moonshot AI 的 Kimi K2：

前往 Moonshot AI 控制台 (opens in a new tab)，创建账号，并点击 Create API key。
运行 /connect 命令并搜索 Moonshot AI。
```
/connect
```
输入你的 Moonshot API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择 Kimi K2。
```
/models
```

MiniMax

前往 MiniMax API 控制台 (opens in a new tab)，创建账号，并生成一个 API key。
运行 /connect 命令并搜索 MiniMax。
```
/connect
```
输入你的 MiniMax API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型，例如 M2.1。
```
/models
```

Modal

为要使用的模型创建共享 Endpoint (opens in a new tab)。
创建 proxy token (opens in a new tab)，然后用句点连接其 ID 与 secret：
```
wk-<id>.ws-<secret>
```
运行 /connect，搜索 Modal 并输入组合后的 proxy token。
```
/connect
```
运行 /models，选择 Modal workspace 中的一个 endpoint。
```
/models
```

NVIDIA

NVIDIA 通过 build.nvidia.com (opens in a new tab) 免费提供对 Nemotron 模型以及许多其他开源模型的访问。

前往 build.nvidia.com (opens in a new tab)，创建账号，并生成一个 API key。
运行 /connect 命令并搜索 NVIDIA。
```
/connect
```
输入你的 NVIDIA API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型，例如 nemotron-3-super-120b-a12b。
```
/models
```

本地部署 / NIM

你也可以通过设置自定义 base URL，借助 NVIDIA NIM (opens in a new tab) 在本地使用 NVIDIA 模型。

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "nvidia": {
      "options": {
        "baseURL": "http://localhost:8000/v1"
      }
    }
  }
}

环境变量

或者，将你的 API key 设置为环境变量。

export NVIDIA_API_KEY=nvapi-your-key-here

Nebius Token Factory

前往 Nebius Token Factory 控制台 (opens in a new tab)，创建账号，并点击 Add Key。
运行 /connect 命令并搜索 Nebius Token Factory。
```
/connect
```
输入你的 Nebius Token Factory API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型，例如 Kimi K2 Instruct。
```
/models
```

Ollama

你可以配置 opencode 通过 Ollama 使用本地模型。

Tip: Ollama 可以自动为 OpenCode 完成配置。详情请参阅 Ollama 集成文档 (opens in a new tab)。

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama (local)",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "llama2": {
          "name": "Llama 2"
        }
      }
    }
  }
}

在这个例子中：

ollama 是自定义的 provider ID。可以是你想要的任意字符串。
npm 指定该 provider 使用的包。这里使用 @ai-sdk/openai-compatible，适用于任何 OpenAI 兼容的 API。
name 是 provider 在 UI 中的显示名称。
options.baseURL 是本地服务器的端点。
models 是模型 ID 到其配置的映射。模型名称会显示在模型选择列表中。

Tip: 如果工具调用不工作，请尝试在 Ollama 中增大 num_ctx。从 16k - 32k 左右开始尝试。

Ollama Cloud

在 OpenCode 中使用 Ollama Cloud：

前往 https://ollama.com/ (opens in a new tab) 并登录或创建账号。
导航到 Settings > Keys 并点击 Add API Key 以生成一个新的 API key。
复制该 API key 以便在 OpenCode 中使用。
运行 /connect 命令并搜索 Ollama Cloud。
```
/connect
```
输入你的 Ollama Cloud API key。
```
┌ API key
│
│
└ enter
```
重要：在 OpenCode 中使用云端模型之前，你必须先在本地拉取模型信息：
```
ollama pull gpt-oss:20b-cloud
```
运行 /models 命令来选择你的 Ollama Cloud 模型。
```
/models
```

OpenAI

我们推荐注册 ChatGPT Plus 或 Pro (opens in a new tab)。

注册完成后，运行 /connect 命令并选择 OpenAI。
```
/connect
```
在这里你可以选择 ChatGPT Plus/Pro 选项，它会打开你的浏览器并要求你进行身份验证。
```
┌ Select auth method
│
│ ChatGPT Plus/Pro
│ Manually enter API Key
└
```
现在当你使用 /models 命令时，所有 OpenAI 模型都应该可用了。
```
/models
```

计算区域

对于 ChatGPT OAuth，当 workspace 凭据声明区域推理驻留要求时，OpenCode 会自动应用该要求。它直接转发凭据中的 compute residency 值，而不是维护固定区域列表。静态数据驻留并不代表区域推理。

使用 API key

如果你已经有一个 API key，你可以选择 Manually enter API Key 并在终端中粘贴它。

OpenCode Zen

OpenCode Zen 是由 OpenCode 团队提供的一份经过测试和验证的模型清单。了解更多。

登录 OpenCode Zen (opens in a new tab) 并点击 Create API Key。
运行 /connect 命令并搜索 OpenCode Zen。
```
/connect
```
输入你的 OpenCode API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型，例如 Qwen 3 Coder 480B。
```
/models
```

OpenRouter

前往 OpenRouter 仪表盘 (opens in a new tab)，点击 Create API Key，并复制该 key。
运行 /connect 命令并搜索 OpenRouter。
```
/connect
```
输入该 provider 的 API key。
```
┌ API key
│
│
└ enter
```

许多 OpenRouter 模型默认已预加载，运行 /models 命令来选择你想要的那一个。

/models

你也可以通过 opencode 配置添加额外的模型。

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openrouter": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}

你也可以通过 opencode 配置自定义它们。下面是一个指定 provider 的例子。

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openrouter": {
      "models": {
        "moonshotai/kimi-k2": {
          "options": {
            "provider": {
              "order": ["baseten"],
              "allow_fallbacks": false
            }
          }
        }
      }
    }
  }
}

LLM Gateway

前往 LLM Gateway 仪表盘 (opens in a new tab)，点击 Create API Key，并复制该 key。
运行 /connect 命令并搜索 LLM Gateway。
```
/connect
```
输入该 provider 的 API key。
```
┌ API key
│
│
└ enter
```

许多 LLM Gateway 模型默认已预加载，运行 /models 命令来选择你想要的那一个。

/models

你也可以通过 opencode 配置添加额外的模型。

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llmgateway": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}

你也可以通过 opencode 配置自定义它们。下面是一个指定 provider 的例子。

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llmgateway": {
      "models": {
        "glm-4.7": {
          "name": "GLM 4.7"
        },
        "gpt-5.2": {
          "name": "GPT-5.2"
        },
        "gemini-2.5-pro": {
          "name": "Gemini 2.5 Pro"
        },
        "claude-3-5-sonnet-20241022": {
          "name": "Claude 3.5 Sonnet"
        }
      }
    }
  }
}

Poolside

Poolside (opens in a new tab) 通过 OpenAI-compatible API 提供其模型。

前往 platform.poolside.ai (opens in a new tab)，登录后打开 API Keys 标签页，点击 New key 生成 API key。
运行 /connect 并搜索 Poolside。
```
/connect
```
输入 Poolside API key。
```
┌ API key
│
│
└ enter
```
运行 /models 选择模型。
```
/models
```

Poolside 部署

如果组织运行自己的 Poolside deployment，请将其配置为自定义 OpenAI-compatible provider。把管理员提供的 API key 或 token 存入 ~/.secrets/poolside-key，使用唯一的 provider ID，并添加 deployment 提供的 model ID。

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "poolside-deployment": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Poolside deployment",
      "options": {
        "baseURL": "https://poolside.example.com/openai/v1",
        "apiKey": "{file:~/.secrets/poolside-key}"
      },
      "models": {
        "<served-model-id>": {
          "name": "Poolside deployment model",
          "reasoning": true,
          "interleaved": {
            "field": "reasoning_content"
          }
        }
      }
    }
  }
}

将 poolside.example.com 替换为 deployment host，将 <served-model-id> 替换为 /openai/v1/models endpoint 返回的 model ID。模型可用性和 thinking 行为取决于 deployment 配置。

Tip: 你也可以安装 Poolside Agent CLI (opens in a new tab)，直接从终端使用 Poolside agents。

SAP AI Core

SAP AI Core 通过一个统一平台提供对来自 OpenAI、Anthropic、Google、Amazon、Meta、Mistral 和 AI21 的 40+ 个模型的访问。

前往你的 SAP BTP Cockpit (opens in a new tab)，导航到你的 SAP AI Core 服务实例，并创建一个 service key。

Tip: 该 service key 是一个 JSON 对象，包含 clientid、clientsecret、url 和 serviceurls.AI_API_URL。你可以在 BTP Cockpit 中 Services > Instances and Subscriptions 下找到你的 AI Core 实例。
运行 /connect 命令并搜索 SAP AI Core。
```
/connect
```

输入你的 service key JSON。

┌ Service key
│
│
└ enter

或者设置 AICORE_SERVICE_KEY 环境变量：

AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}' opencode

或者将其添加到你的 bash profile：

~/.bash_profile

export AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}'

可选地设置 deployment ID 和 resource group：
```
AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode
```
Note: 这些设置是可选的，应根据你的 SAP AI Core 设置进行配置。
运行 /models 命令从 40+ 个可用模型中进行选择。
```
/models
```

STACKIT

STACKIT AI Model Serving 提供一个完全托管的主权托管环境来运行 AI 模型，聚焦于 Llama、Mistral 和 Qwen 等 LLM，并在欧洲基础设施上实现最大程度的数据主权。

前往 STACKIT Portal (opens in a new tab)，导航到 AI Model Serving，并为你的项目创建一个 auth token。

Tip: 在创建 auth token 之前，你需要先有一个 STACKIT 客户账号、用户账号和项目。
运行 /connect 命令并搜索 STACKIT。
```
/connect
```
输入你的 STACKIT AI Model Serving auth token。
```
┌ API key
│
│
└ enter
```
运行 /models 命令从可用模型中进行选择，例如 Qwen3-VL 235B 或 Llama 3.3 70B。
```
/models
```

OVHcloud AI Endpoints

前往 OVHcloud 面板 (opens in a new tab)。导航到 Public Cloud 部分、AI & Machine Learning > AI Endpoints，并在 API Keys 标签页中点击 Create a new API key。
运行 /connect 命令并搜索 OVHcloud AI Endpoints。
```
/connect
```
输入你的 OVHcloud AI Endpoints API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型，例如 gpt-oss-120b。
```
/models
```

Scaleway

在 Opencode 中使用 Scaleway Generative APIs (opens in a new tab)：

前往 Scaleway Console IAM settings (opens in a new tab) 生成一个新的 API key。
运行 /connect 命令并搜索 Scaleway。
```
/connect
```
输入你的 Scaleway API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型，例如 devstral-2-123b-instruct-2512 或 gpt-oss-120b。
```
/models
```

SCX.ai

SCX.ai (opens in a new tab) 是澳大利亚主权 AI 平台，通过 OpenAI-compatible API 提供开放模型，并托管在澳大利亚的可再生能源基础设施上。

前往 SCX.ai platform (opens in a new tab) 创建账户并生成 API key。
运行 /connect 并搜索 SCX.ai。
```
/connect
```
输入 SCX.ai API key。
```
┌ API key
│
│
└ enter
```
运行 /models，选择 MiniMax-M2.7 或 GLM-5.2 等模型。
```
/models
```

Snowflake Cortex

Snowflake Cortex (opens in a new tab) 让你可以通过兼容 OpenAI 的 API 访问前沿模型（Claude、OpenAI GPT-5 等）。所有推理都在 Snowflake 边界内运行，并以 Snowflake credits 计费。关于各模型的具体费率，参见 Snowflake Service Consumption Table (opens in a new tab)。

还没有 Snowflake 账号？注册免费试用 (opens in a new tab)。

opencode 用于编写代码、编辑文件和运行命令的核心工作流依赖于 tool calling。在 Snowflake Cortex 中，只有 Claude 和 OpenAI 系列支持这一点。为了支持核心工作流，该 provider 仅限于这些系列。

OpenCode 支持两种身份验证方法：

浏览器 OAuth（推荐） —— 使用你的 IdP/SSO 登录；无需管理密钥，token 会自动刷新。
手动 bearer token —— 从 Snowflake 控制台粘贴一个 PAT 或 JWT。

浏览器 OAuth（推荐）

运行 /connect 命令并搜索 Snowflake Cortex。
```
/connect
```

选择 Login with Snowflake (External Browser)。

┌ Select auth method
│
│ Login with Snowflake (External Browser)
│ Paste PAT or bearer token manually
└

在提示时输入你的账号标识符 (opens in a new tab)，例如 myorg-myaccount 或 xy12345.us-east-1。
```
┌ Snowflake Account Identifier
│
│
└ enter
```
可选地输入一个 Snowflake 角色来限定会话范围（例如 SYSADMIN）。留空则使用你的默认角色。
在打开的浏览器中完成登录。OpenCode 会自动捕获 OAuth 回调并存储 token——无需手动复制粘贴。
运行 /models 命令来选择一个模型。
```
/models
```

Note: 浏览器 OAuth 使用 Snowflake 内置的 SNOWFLAKE$LOCAL_APPLICATION 安全集成（文档 (opens in a new tab)），目前正在向所有账号推广。要检查你的账号中是否可用：
SHOW SECURITY INTEGRATIONS LIKE 'SNOWFLAKE$LOCAL_APPLICATION';
如果结果为空，在该集成推广到你的账号之前，请改用下方的手动 bearer token方法。

手动 bearer token

如果你更倾向于直接粘贴一个 token，或者 SNOWFLAKE$LOCAL_APPLICATION 尚未在你的账号中可用：

在你的 Snowflake 账号中生成一个 Programmatic Access Token (PAT) (opens in a new tab)。
运行 /connect 命令，搜索 Snowflake Cortex，然后选择 Paste PAT or bearer token manually。
在提示时输入你的账号标识符 (opens in a new tab)。
粘贴你的 PAT。
运行 /models 命令来选择一个模型。
```
/models
```

环境变量

对于 CI 或无头环境，请在启动 opencode 之前设置一个 PAT 或 JWT：

export SNOWFLAKE_ACCOUNT=myorg-myaccount
export SNOWFLAKE_CORTEX_TOKEN=your-pat-or-jwt

Note: SNOWFLAKE_CORTEX_TOKEN 只接受 PAT 或 JWT——浏览器 OAuth 流程仅能通过 /connect 使用，无法通过环境变量配置。为了向后兼容，仍然支持 SNOWFLAKE_CORTEX_PAT。

模型目录会自动提供。只需一个最简的 opencode.json 即可：

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "model": "snowflake-cortex/claude-sonnet-4-6",
  "small_model": "snowflake-cortex/claude-haiku-4-5"
}

Together AI

前往 Together AI 控制台 (opens in a new tab)，创建账号，并点击 Add Key。
运行 /connect 命令并搜索 Together AI。
```
/connect
```
输入你的 Together AI API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型，例如 Kimi K2 Instruct。
```
/models
```

Venice AI

前往 Venice AI 控制台 (opens in a new tab)，创建账号，并生成一个 API key。
运行 /connect 命令并搜索 Venice AI。
```
/connect
```
输入你的 Venice AI API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型，例如 Llama 3.3 70B。
```
/models
```

Vercel AI Gateway

Vercel AI Gateway 让你能通过统一端点访问来自 OpenAI、Anthropic、Google、xAI 等的模型。模型按标价提供，不加价。

前往 Vercel 仪表盘 (opens in a new tab)，导航到 AI Gateway 标签页，并点击 API keys 来创建一个新的 API key。
运行 /connect 命令并搜索 Vercel AI Gateway。
```
/connect
```
输入你的 Vercel AI Gateway API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型。
```
/models
```

你也可以通过 opencode 配置自定义模型。下面是一个指定 provider 路由顺序的例子。

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "vercel": {
      "models": {
        "anthropic/claude-sonnet-4": {
          "options": {
            "order": ["anthropic", "vertex"]
          }
        }
      }
    }
  }
}

一些有用的路由选项：

选项	说明
`order`	要尝试的 provider 顺序
`only`	限制为特定的 provider
`zeroDataRetention`	仅使用具有零数据保留策略的 provider

xAI

两种认证方式：通过 device-code OAuth 使用 SuperGrok 订阅，或使用 xAI console 的 pay-as-you-go API key。

选项 A — SuperGrok 订阅

运行 /connect 并搜索 xAI。
```
/connect
```
选择 SuperGrok Subscription。在支持时，OpenCode 会打开已预填 user code 的 xAI 验证链接。
批准 consent screen。如果 xAI 要求输入 code，请填写 OpenCode 显示的 user code。批准后，OpenCode 会轮询 xAI token endpoint 并保存 OAuth token。
运行 /models 选择 Grok 模型。
```
/models
```

OpenCode 会自动刷新 OAuth access token。任何包含 Grok API 访问权限的 Grok 或 X Premium 套餐都可使用，无需单独的 XAI_API_KEY。

选项 B — API key

前往 xAI console (opens in a new tab) 创建账户并生成 API key。
运行 /connect 并搜索 xAI。
```
/connect
```
选择 Manually enter API Key 并粘贴 xAI API key。
```
┌ API key
│
│
└ enter
```
运行 /models，选择 Grok Beta 等模型。
```
/models
```

Z.AI

前往 Z.AI API 控制台 (opens in a new tab)，创建账号，并点击 Create a new API key。
运行 /connect 命令并搜索 Z.AI。
```
/connect
```
如果你订阅了 GLM Coding Plan，请选择 Z.AI Coding Plan。
输入你的 Z.AI API key。
```
┌ API key
│
│
└ enter
```
运行 /models 命令来选择一个模型，例如 GLM-4.7。
```
/models
```

ZenMux

前往 ZenMux 仪表盘 (opens in a new tab)，点击 Create API Key，并复制该 key。
运行 /connect 命令并搜索 ZenMux。
```
/connect
```
输入该 provider 的 API key。
```
┌ API key
│
│
└ enter
```

许多 ZenMux 模型默认已预加载，运行 /models 命令来选择你想要的那一个。

/models

你也可以通过 opencode 配置添加额外的模型。

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "zenmux": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}

自定义提供商

要添加任何未在 /connect 命令中列出的 OpenAI 兼容 provider：

Tip: 你可以将任何 OpenAI 兼容的 provider 与 opencode 配合使用。大多数现代 AI provider 都提供 OpenAI 兼容的 API。

运行 /connect 命令并向下滚动到 Other。

$ /connect
 
┌  Add credential
│
◆  Select provider
│  ...
│  ● Other
└

为该 provider 输入一个唯一的 ID。
```
$ /connect
 
┌  Add credential
│
◇  Enter provider id
│  myprovider
└
```
Note: 选择一个好记的 ID，你将在配置文件中用到它。

为该 provider 输入你的 API key。

$ /connect
 
┌  Add credential
│
▲  This only stores a credential for myprovider - you will need to configure it in opencode.json, check the docs for examples.
│
◇  Enter your API key
│  sk-...
└

在你的项目目录中创建或更新你的 opencode.json 文件：
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "myprovider": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "My AI Provider Display Name",
      "options": {
        "baseURL": "https://api.myprovider.com/v1"
      },
      "models": {
        "my-model-name": {
          "name": "My Model Display Name"
        }
      }
    }
  }
}
```
以下是这些配置选项：
- npm ：要使用的 AI SDK 包，OpenAI 兼容 provider（用于 /v1/chat/completions ）使用 @ai-sdk/openai-compatible。如果你的 provider/模型使用 /v1/responses ，请使用 @ai-sdk/openai。
- name ：UI 中的显示名称。
- models ：可用的模型。
- options.baseURL ：API 端点 URL。
- options.apiKey ：可选地设置 API key，如果不使用 auth 的话。
- options.headers ：可选地设置自定义 header。
下面的例子中有更多进阶选项。
运行 /models 命令，你的自定义 provider 和模型就会出现在选择列表中。

示例

下面是一个设置 apiKey、headers 和模型 limit 选项的例子。

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "myprovider": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "My AI Provider Display Name",
      "options": {
        "baseURL": "https://api.myprovider.com/v1",
        "apiKey": "{env:ANTHROPIC_API_KEY}",
        "headers": {
          "Authorization": "Bearer custom-token"
        }
      },
      "models": {
        "my-model-name": {
          "name": "My Model Display Name",
          "limit": {
            "context": 200000,
            "output": 65536
          }
        }
      }
    }
  }
}

配置详情：

apiKey ：使用 env 变量语法设置，了解更多。
headers ：随每个请求发送的自定义 header。
limit.context ：模型接受的最大输入 token 数。
limit.output ：模型可以生成的最大 token 数。

limit 字段让 OpenCode 能够理解你还剩多少上下文。标准 provider 会自动从 models.dev 拉取这些信息。

故障排除

如果你在配置某个 provider 时遇到问题，请检查以下内容：

检查 auth 设置：运行 opencode auth list 查看该 provider 的凭证是否已添加到你的配置中。这不适用于像 Amazon Bedrock 这样依赖环境变量进行 auth 的 provider。
对于自定义 provider，请检查 opencode 配置并：
- 确保在 /connect 命令中使用的 provider ID 与你 opencode 配置中的 ID 匹配。
- 为该 provider 使用了正确的 npm 包。例如，Cerebras 使用 @ai-sdk/cerebras。对于所有其他 OpenAI 兼容的 provider，使用 @ai-sdk/openai-compatible（用于 /v1/chat/completions ）；如果某个模型使用 /v1/responses ，则使用 @ai-sdk/openai。对于同一个 provider 下的混合配置，你可以通过 provider.npm 按模型覆盖。
- 检查 options.baseURL 字段中使用的 API 端点是否正确。

配置网络

文档来源（MIT）