提供商

在 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.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 中的任何其他提供商一样。并且完全可以选择是否使用它。

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

你需要在 Amazon Bedrock 中拥有你想要使用的模型的访问权限。
你需要设置以下环境变量之一：
- AWS_ACCESS_KEY_ID：你可以通过创建 IAM 用户并为其生成访问密钥来获取。
- AWS_PROFILE：首先使用 aws sso login 通过 AWS IAM Identity Center（或 AWS SSO）登录。然后获取你想要使用的配置文件的名称。
- AWS_BEARER_TOKEN_BEDROCK：你可以从 Amazon Bedrock 控制台生成一个长期 API 密钥。
获得上述任一凭证后，在运行 opencode 时设置它。
Terminal window
```
AWS_ACCESS_KEY_ID=XXX opencode
```
或者将其添加到你的 bash 配置文件中。
~/.bash_profile
```
export AWS_ACCESS_KEY_ID=XXX
```
运行 /models 命令来选择你想要的模型。
```
/models
```

Anthropic

我们建议注册 Claude Pro 或 Max。

注册后，运行 /connect 命令并选择 Anthropic。
```
/connect
```
在这里你可以选择 Claude Pro/Max 选项，它将打开你的浏览器并要求你进行身份验证。
```
┌ 选择认证方式
│
│ Claude Pro/Max
│ 创建 API 密钥
│ 手动输入 API 密钥
└
```
现在，当你使用 /models 命令时，所有 Anthropic 模型都应该可用。
```
/models
```

使用 API 密钥

如果你没有 Pro/Max 订阅，也可以选择 创建 API 密钥。它同样会打开你的浏览器，要求你登录 Anthropic，并提供一个可以粘贴到终端中的代码。

或者，如果你已经有一个 API 密钥，可以选择 手动输入 API 密钥 并将其粘贴到终端中。

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
```
将你的资源名称设置为环境变量：
Terminal window
```
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
```
将你的资源名称设置为环境变量：
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 等提供商的大模型。通过统一计费，您无需为每个提供商准备单独的 API 密钥。

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

将您的账户 ID 和网关 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 控制台，创建账户，然后点击 创建新的 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
```

Fireworks AI

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

GitHub Copilot

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

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

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

┌ 使用 GitHub Copilot 登录
│
│ https://github.com/login/device
│
│ 输入代码: 8F43-6FCF
│
└ 等待授权...

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

Google Vertex AI

要在 OpenCode 中使用 Google Vertex AI：

前往 Google Cloud 控制台的 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 网关会根据模型自动将你的请求路由到相应的供应商。

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

如需了解更多供应商以及缓存和速率限制等高级功能，请查阅 Helicone 文档。

可选配置

如果你发现 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": {
          // 模型 ID (来自 Helicone 的模型目录页面)
          "name": "GPT-4o", // 你为该模型自定义的名称
        },
        "claude-sonnet-4-20250514": {
          "name": "Claude Sonnet 4",
        },
      },
    },
  },
}

自定义请求头

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

会话追踪

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 头部

Header	描述
`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.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 指定了用于此提供商的包。这里，@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.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 指定用于此提供商的 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 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

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

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

Ollama Cloud

要在 OpenCode 中使用 Ollama Cloud：

访问 https://ollama.com/ 并登录或创建账户。
导航到设置 > 密钥，点击 添加 API 密钥 以生成新的 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

访问 OpenAI Platform 控制台，点击 创建新的密钥，并复制该密钥。
运行 /connect 命令并搜索 OpenAI。
```
/connect
```
输入该提供商的 API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择你想要的模型。
```
/models
```

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.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 服务实例，并创建一个服务密钥。

服务密钥是一个包含 clientid、clientsecret、url 和 serviceurls.AI_API_URL 的 JSON 对象。您可以在 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 和资源组：
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 选项卡中，点击 创建新的 API 密钥。
运行 /connect 命令并搜索 OVHcloud AI Endpoints。
```
/connect
```
输入您的 OVHcloud AI Endpoints API 密钥。
```
┌ API key
│
│
└ enter
```
运行 /models 命令以选择模型，例如 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 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"]
          }
        }
      }
    }
  }
}

一些有用的路由选项：

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

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.ai/config.json",
  "provider": {
    "zenmux": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}

自定义提供商

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

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

$ /connect

┌  添加凭证
│
◆  选择提供商
│  ...
│  ● 其他
└

为提供商输入一个唯一的 ID。
Terminal window
```
$ /connect

┌  添加凭证
│
◇  输入提供商 ID
│  myprovider
└
```
选择一个容易记住的 ID，你将在配置文件中使用它。

输入你为该提供商准备的 API 密钥。

$ /connect

┌  添加凭证
│
▲  这仅为 myprovider 存储一个凭证 - 你需要在 opencode.json 中配置它，请查看文档中的示例。
│
◇  输入你的 API 密钥
│  sk-...
└

在你的项目目录中创建或更新 opencode.json 文件：
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 命令，你的自定义提供商和模型将出现在选择列表中。

示例

以下是一个设置 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 获取这些信息。

故障排除

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

检查身份验证设置：运行 opencode auth list 命令，查看该提供商的凭据是否已添加到您的配置中。这不适用于像 Amazon Bedrock 这样依赖环境变量进行身份验证的提供商。
对于自定义提供商，请检查 opencode 配置并：
- 确保在 /connect 命令中使用的提供商 ID 与您的 opencode 配置中的 ID 匹配。
- 为提供商使用了正确的 npm 包。例如，对于 Cerebras 使用 @ai-sdk/cerebras。对于所有其他 OpenAI 兼容的提供商，使用 @ai-sdk/openai-compatible。
- 检查 options.baseURL 字段中使用的 API 端点是否正确。