提供商 Providers

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

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

要添加提供商，你需要：

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

凭据 Credentials

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

配置 Config

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

基础 URL Base URL

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

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

OpenCode Zen

OpenCode Zen 是 OpenCode 团队提供的经过测试并验证可与 OpenCode 良好协作的模型列表。了解更多。

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

它的工作方式与 OpenCode 中的任何其他提供商一样，并且完全是选择性使用的。

目录 Directory

让我们详细看看一些提供商。如果你想将提供商添加到列表中，欢迎提交 PR。

302.AI

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

Amazon Bedrock

要在 OpenCode 中使用 Amazon Bedrock：

前往 Amazon Bedrock 控制台中的 Model catalog (模型目录) 并申请访问你想要的模型。

你需要有权访问 Amazon Bedrock 中你想要的模型。
配置认证 使用以下方法之一：

环境变量（快速开始） Environment Variables (Quick Start)

在运行 opencode 时设置这些环境变量中的一个：
Terminal window
```
# 选项 1: 使用 AWS access keys
AWS_ACCESS_KEY_ID=XXX AWS_SECRET_ACCESS_KEY=YYY opencode

# 选项 2: 使用命名 AWS profile
AWS_PROFILE=my-profile opencode

# 选项 3: 使用 Bedrock bearer token
AWS_BEARER_TOKEN_BEDROCK=XXX opencode
```
或者将它们添加到你的 bash 配置文件中：
~/.bash_profile
```
export AWS_PROFILE=my-dev-profile
export AWS_REGION=us-east-1
```
配置文件（推荐） Configuration File (Recommended)

对于项目特定或持久配置，使用 opencode.json：
opencode.json
```
{
  "$schema": "https://opencode.ai/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 端点 Advanced: VPC Endpoints

如果你正在为 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"
      }
    }
  }
}
```
endpoint 选项是通用 baseURL 选项的别名，使用 AWS 特定术语。如果同时指定了 endpoint 和 baseURL，则 endpoint 优先。

认证方法 Authentication Methods
- AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY: 创建 IAM 用户并在 AWS 控制台中生成访问密钥
- 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 Roles for Service Accounts) 或其他具有 OIDC 联合的 Kubernetes 环境。在使用服务帐户注释时，Kubernetes 会自动注入这些环境变量。
认证优先级 Authentication Precedence

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

对于自定义推理配置文件，使用模型和提供商名称作为键，并将 id 属性设置为 arn。这确保了正确的缓存：

{
  "$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
│
│ Claude Pro/Max
│ Create an API Key
│ Manually enter API Key
└
```
现在当你使用 /models 命令时，所有 Anthropic 模型都应该可用。
```
/models
```

Anthropic 官方不支持在 OpenCode 中使用你的 Claude Pro/Max 订阅。

使用 API 密钥 Using API keys

如果你没有 Pro/Max 订阅，也可以选择 Create an API Key。它也会打开你的浏览器并要求你登录 Anthropic，并给你一个可以粘贴到终端的代码。

或者如果你已经有一个 API 密钥，你可以选择 Manually enter API Key 并将其粘贴到你的终端。

Azure OpenAI

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

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

Azure Cognitive Services

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

部署名称必须与模型名称匹配，opencode 才能正常工作。
运行 /connect 命令并搜索 Azure Cognitive Services。
```
/connect
```
输入你的 API 密钥。
```
┌ API key
│
│
└ enter
```
将你的资源名称设置为环境变量：
Terminal window
```
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 Gateway 允许你通过统一的端点访问来自 OpenAI、Anthropic、Workers AI 等的模型。使用 Unified Billing，你不需要为每个提供商使用单独的 API 密钥。

前往 Cloudflare 仪表板，导航到 AI > AI Gateway，并创建一个新网关。

将你的 Account ID 和 Gateway ID 设置为环境变量。

export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
export CLOUDFLARE_GATEWAY_ID=your-gateway-id

运行 /connect 命令并搜索 Cloudflare AI Gateway。
```
/connect
```
输入你的 Cloudflare API 令牌。
```
┌ API key
│
│
└ enter
```
或者将其设置为环境变量。
~/.bash_profile
```
export CLOUDFLARE_API_TOKEN=your-api-token
```

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

/models

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

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

Cortecs

前往 Cortecs 控制台，创建一个帐户，并生成一个 API 密钥。
运行 /connect 命令并搜索 Cortecs。
```
/connect
```
输入你的 Cortecs API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令选择一个模型，如 Kimi K2 Instruct。
```
/models
```

DeepSeek

前往 DeepSeek 控制台，创建一个帐户，并点击 Create new API key。
运行 /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 控制台，创建一个帐户，并点击 Create API Key。
运行 /connect 命令并搜索 Fireworks AI。
```
/connect
```
输入你的 Fireworks AI API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令选择一个模型，如 Kimi K2 Instruct。
```
/models
```

GitLab Duo

GitLab Duo 提供了 AI 驱动的智能体聊天，通过 GitLab 的 Anthropic 代理具有原生工具调用能力。

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

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

使用个人访问令牌 Using Personal Access Token
1. 前往 GitLab 用户设置 > Access Tokens
2. 点击 Add new token
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 Self-Hosted GitLab

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 网关：

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 for Self-Hosted instances

为了使 Oauth 在你的自托管实例中工作，你需要创建一个新应用程序（Settings → Applications），回调 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 主页上。

配置 Configuration

通过 opencode.json 自定义：

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

GitLab API 工具（可选，但强烈推荐） GitLab API Tools (Optional, but highly recommended)

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

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

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

GitHub Copilot

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

运行 /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 Console 中的 Model Garden，检查你所在区域可用的模型。

你需要拥有一个启用了 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 时设置它们。
Terminal window
```
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 控制台，点击 Create API Key，并复制密钥。
运行 /connect 命令并搜索 Groq。
```
/connect
```
输入提供商的 API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令选择你想要的模型。
```
/models
```

Hugging Face

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

前往 Hugging Face 设置创建一个有权调用 Inference Providers 的令牌。
运行 /connect 命令并搜索 Hugging Face。
```
/connect
```
输入你的 Hugging Face 令牌。
```
┌ API key
│
│
└ enter
```
运行 /models 命令选择一个模型，如 Kimi-K2-Instruct 或 GLM-4.6。
```
/models
```

Helicone

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

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

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

可选配置 Optional Configs

如果 Helicone 的某个功能或模型未通过 opencode 自动配置，你随时可以自行配置。

这是 Helicone 的模型目录，你需要用它来获取你想添加的模型的 ID。

{
  "$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",
        },
      },
    },
  },
}

自定义头 Custom Headers

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

{
  "$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",
        },
      },
    },
  },
}

会话跟踪 Session tracking

Helicone 的 Sessions 功能允许你将相关的 LLM 请求分组在一起。使用 opencode-helicone-session 插件自动将每个 OpenCode 对话记录为 Helicone 中的一个会话。

npm install -g opencode-helicone-session

将其添加到你的配置中。

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

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

常见 Helicone 头 Common Helicone headers

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

请参阅 Helicone Header Directory 以获取所有可用的头。

llama.cpp

你可以配置 opencode 使用 llama.cpp 的 llama-server 实用程序作为本地模型。

{
  "$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 是自定义提供商 ID。这可以是任何你想要的字符串。
npm 指定用于此提供商的包。在这里，任何兼容 OpenAI 的 API 都使用 @ai-sdk/openai-compatible。
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

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

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

Moonshot AI

要使用 Moonshot AI 的 Kimi K2：

前往 Moonshot AI 控制台，创建一个帐户，并点击 Create API key。
运行 /connect 命令并搜索 Moonshot AI。
```
/connect
```
输入你的 Moonshot 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 控制台，创建一个帐户，并点击 Add Key。
运行 /connect 命令并搜索 Nebius Token Factory。
```
/connect
```
输入你的 Nebius Token Factory API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令选择一个模型，如 Kimi K2 Instruct。
```
/models
```

Ollama

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

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

Ollama Cloud

要在 OpenCode 中使用 Ollama Cloud：

前往 https://ollama.com/ 并登录或创建一个帐户。
导航到 Settings > Keys 并点击 Add API Key 生成一个新的 API 密钥。
复制 API 密钥以在 OpenCode 中使用。
运行 /connect 命令并搜索 Ollama Cloud。
```
/connect
```
输入你的 Ollama Cloud API 密钥。
```
┌ API key
│
│
└ enter
```
重要：在 OpenCode 中使用云模型之前，你必须在本地拉取模型信息：
Terminal window
```
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 密钥 Using API keys

如果你已经有一个 API 密钥，你可以选择 Manually enter API Key 并将其粘贴到你的终端。

OpenCode Zen

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

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

OpenRouter

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

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

/models

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

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

你也可以通过 opencode 配置自定义它们。这是指定提供商的示例

{
  "$schema": "https://opencode.ai/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 的 Services > Instances and Subscriptions 下找到你的 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 和资源组：
Terminal window
```
AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode
```
这些设置是可选的，应根据你的 SAP AI Core 设置进行配置。
运行 /models 命令从 40+ 可用模型中选择。
```
/models
```

OVHcloud AI Endpoints

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

Scaleway

要在 Opencode 中使用 Scaleway Generative APIs：

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

Together AI

前往 Together AI 控制台，创建一个帐户，并点击 Add Key。
运行 /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 Gateway 允许你通过统一的端点访问来自 OpenAI、Anthropic、Google、xAI 等的模型。模型以标价提供，没有加价。

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

你也可以通过你的 opencode 配置自定义模型。这是一个指定提供商路由顺序的示例。

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

一些有用的路由选项：

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

xAI

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

Z.AI

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

ZenMux

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

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

/models

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

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

自定义提供商 Custom provider

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

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

$ /connect

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

为提供商输入一个唯一的 ID。
Terminal window
```
$ /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 文件：

{
  "$schema": "https://opencode.ai/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 包，对于 OpenAI 兼容提供商使用 @ai-sdk/openai-compatible
name: UI 中的显示名称。
models: 可用模型。
options.baseURL: API 端点 URL。
options.apiKey: 可选设置 API 密钥，如果不使用认证。
options.headers: 可选设置自定义头。

下面的示例中有更多高级选项。

运行 /models 命令，你的自定义提供商和模型将出现在选择列表中。

示例 Example

这是一个设置 apiKey、headers 和模型 limit 选项的示例。

{
  "$schema": "https://opencode.ai/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 获取这些信息。

故障排除 Troubleshooting

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

检查认证设置: 运行 opencode auth list 查看提供商的凭据是否已添加到你的配置中。

这不适用于像 Amazon Bedrock 这样依靠环境变量进行认证的提供商。
对于自定义提供商，检查 opencode 配置并：
- 确保 /connect 命令中使用的提供商 ID 与你的 opencode 配置中的 ID 匹配。
- 为提供商使用了正确的 npm 包。例如，对于 Cerebras 使用 @ai-sdk/cerebras。对于所有其他 OpenAI 兼容提供商，使用 @ai-sdk/openai-compatible。
- 检查 options.baseURL 字段中使用的 API 端点是否正确。