提供商

在 OpenCode 中使用任何 LLM 提供商。

OpenCode 使用 AI SDK 和 Models.dev 支持 75+ 个 LLM 提供商，并支持运行本地模型。

要添加提供商，您需要

使用 /connect 命令添加提供商的 API 密钥。
在您的 OpenCode 配置中配置提供商。

凭据

当您使用 /connect 命令添加提供商的 API 密钥时，它们会存储在 ~/.local/share/opencode/auth.json 中。

配置

您可以通过 OpenCode 配置中的 provider 部分自定义提供商。

基本 URL

您可以通过设置 baseURL 选项来自定义任何提供商的基本 URL。这在使用代理服务或自定义端点时非常有用。

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

OpenCode Zen

OpenCode Zen 是 OpenCode 团队提供的一系列模型，这些模型经过测试和验证，可与 OpenCode 良好协作。了解更多。

在 TUI 中运行 /connect 命令，选择 OpenCode Zen，然后前往 opencode.ai/auth。
```
/connect
```
登录，添加您的账单信息，然后复制您的 API 密钥。
粘贴您的 API 密钥。
```
┌ API key
│
│
└ enter
```
在 TUI 中运行 /models 以查看我们推荐的模型列表。
```
/models
```

它与 OpenCode 中的任何其他提供商一样工作，并且完全是可选的。

OpenCode Go

OpenCode Go 是一种低成本订阅计划，可提供对 OpenCode 团队提供的流行开放编码模型的可靠访问，这些模型经过测试和验证，可与 OpenCode 良好协作。

在 TUI 中运行 /connect 命令，选择 OpenCode Go，然后前往 opencode.ai/auth。
```
/connect
```
登录，添加您的账单信息，然后复制您的 API 密钥。
粘贴您的 API 密钥。
```
┌ API key
│
│
└ enter
```
在 TUI 中运行 /models 以查看我们推荐的模型列表。
```
/models
```

它与 OpenCode 中的任何其他提供商一样工作，并且完全是可选的。

前往 Amazon Bedrock 控制台中的 模型目录，请求访问您想要的模型。

您需要拥有 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 配置文件
~/.bash_profile
```
export AWS_PROFILE=my-dev-profile
export AWS_REGION=us-east-1
```
配置文件（推荐）

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

高级：VPC 端点

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

身份验证方法
- AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY: 在 AWS 控制台中创建 IAM 用户并生成访问密钥
- AWS_PROFILE: 使用 ~/.aws/credentials 中的命名配置文件。首先使用 aws configure --profile my-profile 或 aws sso login 进行配置
- AWS_BEARER_TOKEN_BEDROCK: 从 Amazon Bedrock 控制台生成长期 API 密钥
- AWS_WEB_IDENTITY_TOKEN_FILE / AWS_ROLE_ARN: 适用于 EKS IRSA（IAM 服务账户角色）或其他具有 OIDC 联邦的 Kubernetes 环境。在使用服务账户注解时，这些环境变量由 Kubernetes 自动注入。
身份验证优先级

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

{
  "$schema": "https://opencode.ac.cn/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
```

有一些插件允许您将 Claude Pro/Max 模型与 OpenCode 一起使用。Anthropic 明确禁止这样做。

OpenCode 的早期版本捆绑了这些插件，但从 1.3.0 版本开始不再是这种情况。

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

ChatGPT Plus
GitHub Copilot
GitLab Duo

Azure OpenAI

前往 Azure 门户并创建一个 Azure OpenAI 资源。您需要
- 资源名称：这将成为您的 API 端点的一部分 (https://RESOURCE_NAME.openai.azure.com/)
- API 密钥：您的资源中的 KEY 1 或 KEY 2
前往 Azure AI Foundry 并部署一个模型。

部署名称必须与模型名称匹配，opencode 才能正常工作。
运行 /connect 命令并搜索 Azure。
```
/connect
```
输入您的 API 密钥。
```
┌ API key
│
│
└ enter
```
将您的资源名称设置为环境变量
终端窗口
```
AZURE_RESOURCE_NAME=XXX opencode
```
或者将其添加到您的 bash 配置文件
~/.bash_profile
```
export AZURE_RESOURCE_NAME=XXX
```
运行 /models 命令以选择您部署的模型。
```
/models
```

Azure Cognitive Services

前往 Azure 门户并创建一个 Azure OpenAI 资源。您需要
- 资源名称：这将成为您的 API 端点的一部分 (https://AZURE_COGNITIVE_SERVICES_RESOURCE_NAME.cognitiveservices.azure.com/)
- API 密钥：您的资源中的 KEY 1 或 KEY 2
前往 Azure AI Foundry 并部署一个模型。

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

Baseten

前往 Baseten，创建一个帐户，然后生成一个 API 密钥。
运行 /connect 命令并搜索 Baseten。
```
/connect
```
输入您的 Baseten API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择模型。
```
/models
```

Cerebras

前往 Cerebras 控制台，创建一个帐户，然后生成一个 API 密钥。
运行 /connect 命令并搜索 Cerebras。
```
/connect
```
输入您的 Cerebras API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择一个模型，例如 Qwen 3 Coder 480B。
```
/models
```

Cloudflare AI Gateway

Cloudflare AI 网关允许您通过统一端点访问来自 OpenAI、Anthropic、Workers AI 等的模型。通过统一计费，您无需为每个提供商使用单独的 API 密钥。

前往 Cloudflare 仪表板，导航到 AI > AI Gateway，然后创建一个新的网关。记下您的 帐户 ID 和 网关 ID。
运行 /connect 命令并搜索 Cloudflare AI Gateway。
```
/connect
```

在提示时输入您的 帐户 ID。

┌ Enter your Cloudflare Account ID
│
│
└ enter

在提示时输入您的 网关 ID。

┌ Enter your Cloudflare AI Gateway ID
│
│
└ enter

输入您的 Cloudflare API 令牌。
```
┌ Gateway API token
│
│
└ enter
```

运行 /models 命令以选择模型。

/models

您还可以通过 opencode 配置添加模型。

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

或者，您可以设置环境变量而不是使用 /connect。

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 模型，对于支持的模型，无需单独的提供商账户。

前往 Cloudflare 仪表板，导航到 Workers AI，然后选择 使用 REST API 以获取您的 帐户 ID 并创建 API 令牌。
运行 /connect 命令并搜索 Cloudflare Workers AI。
```
/connect
```

在提示时输入您的 帐户 ID。

┌ Enter your Cloudflare Account ID
│
│
└ enter

输入您的 Cloudflare API 密钥。
```
┌ 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 控制台，创建一个帐户，然后生成一个 API 密钥。
运行 /connect 命令并搜索 Cortecs。
```
/connect
```
输入您的 Cortecs API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择一个模型，例如 Kimi K2 Instruct。
```
/models
```

DeepSeek

前往 DeepSeek 控制台，创建一个帐户，然后点击 创建新的 API 密钥。
运行 /connect 命令并搜索 DeepSeek。
```
/connect
```
输入您的 DeepSeek API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择一个 DeepSeek 模型，例如 DeepSeek Reasoner。
```
/models
```

Deep Infra

前往 Deep Infra 仪表板，创建一个帐户，然后生成一个 API 密钥。
运行 /connect 命令并搜索 Deep Infra。
```
/connect
```
输入您的 Deep Infra API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择模型。
```
/models
```

Firmware

前往 Firmware 仪表板，创建一个帐户，然后生成一个 API 密钥。
运行 /connect 命令并搜索 Firmware。
```
/connect
```
输入您的 Firmware API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择模型。
```
/models
```

Fireworks AI

前往 Fireworks AI 控制台，创建一个帐户，然后点击 创建 API 密钥。
运行 /connect 命令并搜索 Fireworks AI。
```
/connect
```
输入您的 Fireworks AI API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择一个模型，例如 Kimi K2 Instruct。
```
/models
```

GitLab Duo

OpenCode 集成了 GitLab Duo Agent Platform，提供由 AI 驱动的代理聊天和原生工具调用功能。

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

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

使用个人访问令牌
1. 前往 GitLab 用户设置 > 访问令牌
2. 点击 添加新令牌
3. 名称：OpenCode，范围：api
4. 复制令牌（以 glpat- 开头）
5. 在终端中输入
运行 /models 命令以查看可用模型。
```
/models
```
提供三种基于 Claude 的模型
- duo-chat-haiku-4-5 (默认) - 快速响应，适用于快速任务
- duo-chat-sonnet-4-5 - 平衡性能，适用于大多数工作流
- duo-chat-opus-4-5 - 最强大，适用于复杂分析

自托管 GitLab

OpenCode 使用一个小型模型来完成一些 AI 任务，例如生成会话标题。它默认配置为使用 Zen 托管的 gpt-5-nano。要将 OpenCode 锁定为仅使用您自己的 GitLab 托管实例，请将以下内容添加到您的 opencode.json 文件中。还建议禁用会话共享。

{
  "$schema": "https://opencode.ac.cn/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 网关

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

或者添加到您的 bash 配置文件

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

自托管实例的 OAuth

为了使 OAuth 在您的自托管实例上正常工作，您需要创建一个新应用程序（设置 → 应用程序），其回调 URL 为 http://127.0.0.1:8080/callback，并具有以下范围

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

然后将应用程序 ID 作为环境变量公开

export GITLAB_OAUTH_CLIENT_ID=your_application_id_here

更多文档请参见 opencode-gitlab-auth 主页。

配置

通过 opencode.json 进行自定义

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

GitLab Duo 代理平台 (DAP) 工作流模型

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

从您的 GitLab 命名空间发现可用模型
如果存在多个模型，则显示选择器
将选定的模型缓存到磁盘以实现快速后续启动
通过 OpenCode 的权限门控工具系统路由工具执行请求

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

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

访问 GitLab 工具（合并请求、问题、管道、CI/CD 等）

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

此插件提供全面的 GitLab 仓库管理功能，包括 MR 审查、问题跟踪、管道监控等。

GitHub Copilot

要将您的 GitHub Copilot 订阅与 opencode 一起使用

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

导航到 github.com/login/device 并输入代码。

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

现在运行 /models 命令以选择您想要的模型。
```
/models
```

Google Vertex AI

要在 OpenCode 中使用 Google Vertex AI

前往 Google Cloud 控制台中的 模型花园，并检查您所在区域可用的模型。

您需要拥有一个已启用 Vertex AI API 的 Google Cloud 项目。
设置所需的环境变量
- GOOGLE_CLOUD_PROJECT: 您的 Google Cloud 项目 ID
- VERTEX_LOCATION（可选）：Vertex AI 的区域（默认为 global）
- 身份验证（选择一个）
  - GOOGLE_APPLICATION_CREDENTIALS: 您的服务账户 JSON 密钥文件的路径
  - 使用 gcloud CLI 进行身份验证：gcloud auth application-default login
在运行 opencode 时设置它们。
终端窗口
```
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id opencode
```
或者将它们添加到您的 bash 配置文件。
~/.bash_profile
```
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
export GOOGLE_CLOUD_PROJECT=your-project-id
export VERTEX_LOCATION=global
```

运行 /models 命令以选择您想要的模型。
```
/models
```

Groq

前往 Groq 控制台，点击 创建 API 密钥，然后复制密钥。
运行 /connect 命令并搜索 Groq。
```
/connect
```
输入提供商的 API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择您想要的。
```
/models
```

Hugging Face

Hugging Face 推理提供商提供对 17+ 提供商支持的开放模型的访问。

前往 Hugging Face 设置以创建具有调用推理提供商权限的令牌。
运行 /connect 命令并搜索 Hugging Face。
```
/connect
```
输入您的 Hugging Face 令牌。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择一个模型，例如 Kimi-K2-Instruct 或 GLM-4.6。
```
/models
```

Helicone

Helicone 是一个 LLM 可观测性平台，为您的 AI 应用程序提供日志记录、监控和分析。Helicone AI 网关根据模型自动将您的请求路由到相应的提供商。

前往 Helicone，创建一个帐户，然后从您的仪表板生成一个 API 密钥。
运行 /connect 命令并搜索 Helicone。
```
/connect
```
输入您的 Helicone API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择模型。
```
/models
```

有关更多提供商和高级功能（如缓存和速率限制），请查看 Helicone 文档。

可选配置

如果您看到 Helicone 中未通过 opencode 自动配置的功能或模型，您始终可以自行配置。

这是 Helicone 的模型目录，您将需要它来获取要添加的模型 ID。

{
  "$schema": "https://opencode.ac.cn/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",
        },
      },
    },
  },
}

自定义请求头

Helicone 支持用于缓存、用户跟踪和会话管理等功能的自定义请求头。使用 options.headers 将它们添加到您的提供商配置中。

{
  "$schema": "https://opencode.ac.cn/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 的会话功能允许您将相关的 LLM 请求分组。使用 opencode-helicone-session 插件自动将每个 OpenCode 对话记录为 Helicone 中的一个会话。

npm install -g opencode-helicone-session

将其添加到您的配置中。

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

该插件将 Helicone-Session-Id 和 Helicone-Session-Name 请求头注入到您的请求中。在 Helicone 的会话页面中，您将看到每个 OpenCode 对话都列为单独的会话。

常见 Helicone 请求头

请求头	描述
`Helicone-Cache-Enabled`	启用响应缓存 (`true`/`false`)
`Helicone-User-Id`	按用户跟踪指标
`Helicone-Property-[Name]`	添加自定义属性（例如，`Helicone-Property-Environment`）
`Helicone-Prompt-Id`	将请求与提示版本关联

有关所有可用请求头，请参阅 Helicone 请求头目录。

llama.cpp

您可以通过 llama.cpp 的 llama-server 工具配置 opencode 以使用本地模型

{
  "$schema": "https://opencode.ac.cn/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 是自定义提供商 ID。这可以是您想要的任何字符串。
npm 指定此提供商要使用的包。在这里，@ai-sdk/openai-compatible 用于任何与 OpenAI 兼容的 API。
name 是提供商在 UI 中的显示名称。
options.baseURL 是本地服务器的端点。
models 是模型 ID 到其配置的映射。模型名称将显示在模型选择列表中。

IO.NET

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

前往 IO.NET 控制台，创建一个帐户，然后生成一个 API 密钥。
运行 /connect 命令并搜索 IO.NET。
```
/connect
```
输入您的 IO.NET API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择模型。
```
/models
```

LM Studio

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

{
  "$schema": "https://opencode.ac.cn/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 是自定义提供商 ID。这可以是您想要的任何字符串。
npm 指定此提供商要使用的包。在这里，@ai-sdk/openai-compatible 用于任何与 OpenAI 兼容的 API。
name 是提供商在 UI 中的显示名称。
options.baseURL 是本地服务器的端点。
models 是模型 ID 到其配置的映射。模型名称将显示在模型选择列表中。

Moonshot AI

要使用 Moonshot AI 的 Kimi K2

前往 Moonshot AI 控制台，创建一个帐户，然后点击 创建 API 密钥。
运行 /connect 命令并搜索 Moonshot AI。
```
/connect
```
输入您的 Moonshot AI API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择 Kimi K2。
```
/models
```

MiniMax

前往 MiniMax API 控制台，创建一个帐户，然后生成一个 API 密钥。
运行 /connect 命令并搜索 MiniMax。
```
/connect
```
输入您的 MiniMax API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择一个模型，例如 M2.1。
```
/models
```

Nebius Token Factory

前往 Nebius Token Factory 控制台，创建一个帐户，然后点击 添加密钥。
运行 /connect 命令并搜索 Nebius Token Factory。
```
/connect
```
输入您的 Nebius Token Factory API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择一个模型，例如 Kimi K2 Instruct。
```
/models
```

Ollama

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

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

在此示例中

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

Ollama Cloud

要在 OpenCode 中使用 Ollama Cloud

前往 https://ollama.ac.cn/ 并登录或创建一个帐户。
导航到设置 > 密钥，然后点击 添加 API 密钥 以生成新的 API 密钥。
复制 API 密钥以在 OpenCode 中使用。
运行 /connect 命令并搜索 Ollama Cloud。
```
/connect
```
输入您的 Ollama Cloud API 密钥。
```
┌ API key
│
│
└ enter
```
重要：在 OpenCode 中使用云模型之前，您必须在本地拉取模型信息
终端窗口
```
ollama pull gpt-oss:20b-cloud
```
运行 /models 命令以选择您的 Ollama Cloud 模型。
```
/models
```

OpenAI

我们建议注册 ChatGPT Plus 或 Pro。

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

使用 API 密钥

如果您已经有 API 密钥，您可以选择 手动输入 API 密钥 并将其粘贴到您的终端中。

OpenCode Zen

OpenCode Zen 是 OpenCode 团队提供的一系列经过测试和验证的模型。了解更多。

登录 OpenCode Zen 并点击 创建 API 密钥。
运行 /connect 命令并搜索 OpenCode Zen。
```
/connect
```
输入您的 OpenCode API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择一个模型，例如 Qwen 3 Coder 480B。
```
/models
```

OpenRouter

前往 OpenRouter 仪表板，点击 创建 API 密钥，然后复制密钥。
运行 /connect 命令并搜索 OpenRouter。
```
/connect
```
输入提供商的 API 密钥。
```
┌ API key
│
│
└ enter
```

许多 OpenRouter 模型默认预加载，运行 /models 命令以选择您想要的模型。

/models

您还可以通过 opencode 配置添加其他模型。

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

您还可以通过 opencode 配置自定义它们。以下是指定提供商的示例

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

SAP AI Core

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

前往您的 SAP BTP Cockpit，导航到您的 SAP AI Core 服务实例，然后创建一个服务密钥。

服务密钥是一个 JSON 对象，包含 clientid、clientsecret、url 和 serviceurls.AI_API_URL。您可以在 BTP Cockpit 的服务 > 实例和订阅 下找到您的 AI Core 实例。
运行 /connect 命令并搜索 SAP AI Core。
```
/connect
```

输入您的服务密钥 JSON。

┌ Service key
│
│
└ enter

或者设置 AICORE_SERVICE_KEY 环境变量

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

或者将其添加到您的 bash 配置文件

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

可选设置部署 ID 和资源组
终端窗口
```
AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode
```
这些设置是可选的，应根据您的 SAP AI Core 设置进行配置。
运行 /models 命令以从 40 多个可用模型中选择。
```
/models
```

STACKIT

STACKIT AI 模型服务为 AI 模型提供完全托管的主权托管环境，专注于 Llama、Mistral 和 Qwen 等 LLM，在欧洲基础设施上实现最大数据主权。

前往 STACKIT 门户，导航到 AI Model Serving，然后为您的项目创建一个身份验证令牌。

在创建身份验证令牌之前，您需要一个 STACKIT 客户帐户、用户帐户和项目。
运行 /connect 命令并搜索 STACKIT。
```
/connect
```
输入您的 STACKIT AI 模型服务身份验证令牌。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以从可用模型中选择，例如 Qwen3-VL 235B 或 Llama 3.3 70B。
```
/models
```

OVHcloud AI Endpoints

前往 OVHcloud 面板。导航到 Public Cloud 部分，AI & Machine Learning > AI Endpoints，然后在 API Keys 选项卡中，点击 创建新的 API 密钥。
运行 /connect 命令并搜索 OVHcloud AI Endpoints。
```
/connect
```
输入您的 OVHcloud AI Endpoints API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择一个模型，例如 gpt-oss-120b。
```
/models
```

Scaleway

要在 OpenCode 中使用 Scaleway 生成式 API

前往 Scaleway 控制台 IAM 设置以生成新的 API 密钥。
运行 /connect 命令并搜索 Scaleway。
```
/connect
```
输入您的 Scaleway API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择一个模型，例如 devstral-2-123b-instruct-2512 或 gpt-oss-120b。
```
/models
```

Together AI

前往 Together AI 控制台，创建一个帐户，然后点击 添加密钥。
运行 /connect 命令并搜索 Together AI。
```
/connect
```
输入您的 Together AI API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择一个模型，例如 Kimi K2 Instruct。
```
/models
```

Venice AI

前往 Venice AI 控制台，创建一个帐户，然后生成一个 API 密钥。
运行 /connect 命令并搜索 Venice AI。
```
/connect
```
输入您的 Venice AI API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择一个模型，例如 Llama 3.3 70B。
```
/models
```

Vercel AI Gateway

Vercel AI 网关允许您通过统一端点访问来自 OpenAI、Anthropic、Google、xAI 等的模型。模型以标价提供，不加价。

前往 Vercel 仪表板，导航到 AI Gateway 选项卡，然后点击 API 密钥 以创建新的 API 密钥。
运行 /connect 命令并搜索 Vercel AI Gateway。
```
/connect
```
输入您的 Vercel AI Gateway API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择模型。
```
/models
```

您还可以通过 opencode 配置自定义模型。以下是指定提供商路由顺序的示例。

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

一些有用的路由选项

选项	描述
`顺序`	要尝试的提供商序列
`仅`	限制为特定提供商
`零数据保留`	仅使用具有零数据保留策略的提供商

xAI

前往 xAI 控制台，创建一个帐户，然后生成一个 API 密钥。
运行 /connect 命令并搜索 xAI。
```
/connect
```
输入您的 xAI API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择一个模型，例如 Grok Beta。
```
/models
```

Z.AI

前往 Z.AI API 控制台，创建一个帐户，然后点击 创建新的 API 密钥。
运行 /connect 命令并搜索 Z.AI。
```
/connect
```
如果您订阅了 GLM Coding Plan，请选择 Z.AI Coding Plan。
输入您的 Z.AI API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择一个模型，例如 GLM-4.7。
```
/models
```

ZenMux

前往 ZenMux 仪表板，点击 创建 API 密钥，然后复制密钥。
运行 /connect 命令并搜索 ZenMux。
```
/connect
```
输入提供商的 API 密钥。
```
┌ API key
│
│
└ enter
```

许多 ZenMux 模型默认预加载，运行 /models 命令以选择您想要的模型。

/models

您还可以通过 opencode 配置添加其他模型。

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

自定义提供商

要添加 /connect 命令中未列出的任何 与 OpenAI 兼容的 提供商

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

$ /connect

┌  Add credential
│
◆  Select provider
│  ...
│  ● Other
└

为提供商输入一个唯一 ID。
终端窗口
```
$ /connect

┌  Add credential
│
◇  Enter provider id
│  myprovider
└
```
选择一个易于记忆的 ID，您将在您的配置文件中使用它。

输入提供商的 API 密钥。

$ /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.ac.cn/config.json",
  "provider": {
    "myprovider": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "My AI ProviderDisplay Name",
      "options": {
        "baseURL": "https://api.myprovider.com/v1"
      },
      "models": {
        "my-model-name": {
          "name": "My Model Display Name"
        }
      }
    }
  }
}
```
以下是配置选项
- npm：要使用的 AI SDK 包，@ai-sdk/openai-compatible 用于与 OpenAI 兼容的提供商（用于 /v1/chat/completions）。如果您的提供商/模型使用 /v1/responses，请使用 @ai-sdk/openai。
- name：在 UI 中的显示名称。
- models：可用模型。
- options.baseURL：API 端点 URL。
- options.apiKey：可选地设置 API 密钥，如果未使用身份验证。
- options.headers：可选地设置自定义请求头。
有关下面示例中的高级选项的更多信息。
运行 /models 命令，您的自定义提供商和模型将出现在选择列表中。

示例

以下是设置 apiKey、headers 和模型 limit 选项的示例。

{
  "$schema": "https://opencode.ac.cn/config.json",
  "provider": {
    "myprovider": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "My AI ProviderDisplay 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：随每个请求发送的自定义请求头。
limit.context：模型接受的最大输入令牌数。
limit.output：模型可以生成的最大令牌数。

limit 字段允许 OpenCode 了解您还剩下多少上下文。标准提供商会自动从 models.dev 中拉取这些信息。

故障排除

如果您在配置提供商时遇到问题，请检查以下内容

检查身份验证设置：运行 opencode auth list 以查看提供商的凭据是否已添加到您的配置中。

这不适用于像 Amazon Bedrock 这样依赖环境变量进行身份验证的提供商。
对于自定义提供商，请检查 opencode 配置和
- 确保 /connect 命令中使用的提供商 ID 与您的 opencode 配置中的 ID 匹配。
- 为提供商使用了正确的 npm 包。例如，Cerebras 使用 @ai-sdk/cerebras。对于所有其他与 OpenAI 兼容的提供商，使用 @ai-sdk/openai-compatible（用于 /v1/chat/completions）；如果模型使用 /v1/responses，则使用 @ai-sdk/openai。对于一个提供商下的混合设置，您可以通过 provider.npm 针对每个模型进行覆盖。
- 检查 options.baseURL 字段中是否使用了正确的 API 端点。