提供商

在 Vikasit Code 中使用任意 LLM 提供商。

Vikasit Code 使用 AI SDK 和 Models.dev，支持 75+ LLM 提供商，同时也支持运行本地模型。

要添加提供商，你需要：

使用 /connect 命令添加提供商的 API 密钥。
在 Vikasit Code 配置中设置该提供商。

凭据

使用 /connect 命令添加提供商的 API 密钥后，凭据会存储在 ~/.local/share/opencode/auth.json 中。

配置

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

自定义 Base URL

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

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

Vikasit Code Zen

Vikasit Code Zen 是由 Vikasit Code 团队提供的模型列表，这些模型已经过测试和验证，能够与 Vikasit Code 良好配合使用。了解更多。

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

它的使用方式与 Vikasit Code 中的其他提供商完全相同，且完全可选。

前往 Amazon Bedrock 控制台中的模型目录，申请访问你想要使用的模型。

你需要先在 Amazon Bedrock 中获得对目标模型的访问权限。
使用以下方法之一配置身份验证：

环境变量（快速上手）

运行 vikasit 时设置以下环境变量之一：
Terminal window
```
# Option 1: Using AWS access keys
AWS_ACCESS_KEY_ID=XXX AWS_SECRET_ACCESS_KEY=YYY vikasit

# Option 2: Using named AWS profile
AWS_PROFILE=my-profile vikasit

# Option 3: Using Bedrock bearer token
AWS_BEARER_TOKEN_BEDROCK=XXX vikasit
```
或者将它们添加到你的 bash 配置文件中：
~/.bash_profile
```
export AWS_PROFILE=my-dev-profile
export AWS_REGION=us-east-1
```
配置文件（推荐）

如需项目级别或持久化的配置，请使用 vikasit.json：
vikasit.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 端点

如果你使用 Bedrock 的 VPC 端点：
vikasit.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 优先。

认证方式
- 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 命令获取的 Token
2. AWS 凭证链 - 配置文件、访问密钥、共享凭证、IAM 角色、Web Identity Token（EKS IRSA）、实例元数据
当设置了 Bearer Token（通过 /connect 或 AWS_BEARER_TOKEN_BEDROCK）时，它的优先级高于所有 AWS 凭证方式，包括已配置的配置文件。
执行 /models 命令选择你想要的模型。
```
/models
```

对于自定义推理配置文件，请在 key 中使用模型名称和提供商名称，并将 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
```

在 Vikasit Code 中使用 Claude Pro/Max 订阅不是 Anthropic 官方支持的用法。

使用 API 密钥

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

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

Azure OpenAI

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

部署名称必须与模型名称一致，Vikasit Code 才能正常工作。
执行 /connect 命令并搜索 Azure。
```
/connect
```
输入你的 API 密钥。
```
┌ API key
│
│
└ enter
```
将资源名称设置为环境变量：
Terminal window
```
AZURE_RESOURCE_NAME=XXX vikasit
```
或者添加到你的 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 并部署一个模型。

部署名称必须与模型名称一致，Vikasit Code 才能正常工作。
执行 /connect 命令并搜索 Azure Cognitive Services。
```
/connect
```
输入你的 API 密钥。
```
┌ API key
│
│
└ enter
```
将资源名称设置为环境变量：
Terminal window
```
AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX vikasit
```
或者添加到你的 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 Token。
```
┌ API key
│
│
└ enter
```
或者将其设置为环境变量。
~/.bash_profile
```
export CLOUDFLARE_API_TOKEN=your-api-token
```

执行 /models 命令选择模型。

/models

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

{
  "$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 通过 GitLab 的 Anthropic 代理提供具有原生工具调用能力的 AI 驱动的代理聊天。

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

选择 OAuth，浏览器会自动打开进行授权。

使用个人访问令牌
1. 前往 GitLab 用户设置 > Access Tokens
2. 点击 Add new token
3. 名称填写 Vikasit Code，范围选择 api
4. 复制令牌（以 glpat- 开头）
5. 在终端中输入该令牌
执行 /models 命令查看可用模型。
```
/models
```
提供三个基于 Claude 的模型：
- duo-chat-haiku-4-5（默认）- 快速响应，适合简单任务
- duo-chat-sonnet-4-5 - 性能均衡，适合大多数工作流
- duo-chat-opus-4-5 - 最强大，适合复杂分析

自托管 GitLab

Vikasit Code 会使用一个小模型来执行部分 AI 任务，例如生成会话标题。默认情况下使用由 Zen 托管的 gpt-5-nano。如果你需要让 Vikasit Code 仅使用你自己的 GitLab 托管实例，请在 vikasit.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 配置文件中：

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 主页。

配置

通过 vikasit.json 进行自定义配置：

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

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

要访问 GitLab 工具（合并请求、Issue、流水线、CI/CD 等）：

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

该插件提供全面的 GitLab 仓库管理功能，包括 MR 审查、Issue 跟踪、流水线监控等。

GitHub Copilot

要在 Vikasit Code 中使用你的 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

要在 Vikasit Code 中使用 Google Vertex AI：

前往 Google Cloud Console 中的模型花园，查看你所在区域可用的模型。

你需要一个启用了 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
在运行 vikasit 时设置：
Terminal window
```
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id vikasit
```
或者添加到你的 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 文档。

可选配置

如果 Helicone 的某些功能或模型未通过 Vikasit Code 自动配置，你随时可以手动配置。

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

自定义请求头

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

会话跟踪

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

npm install -g opencode-helicone-session

将其添加到配置中。

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

该插件会在你的请求中注入 Helicone-Session-Id 和 Helicone-Session-Name 请求头。在 Helicone 的 Sessions 页面中，你可以看到每个 Vikasit Code 对话都作为独立的会话列出。

常用 Helicone 请求头

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

有关所有可用请求头，请参阅 Helicone Header Directory。

llama.cpp

你可以通过 llama.cpp 的 llama-server 工具配置 Vikasit Code 使用本地模型。

{
  "$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 配置 Vikasit Code 使用本地模型。

{
  "$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 指定该提供商使用的包。这里使用 @ai-sdk/openai-compatible 来兼容任何 OpenAI 兼容的 API。
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

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

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

要在 Vikasit Code 中使用 Ollama Cloud：

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

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

Vikasit Code Zen

Vikasit Code Zen 是由 Vikasit Code 团队提供的经过测试和验证的模型列表。了解更多。

登录 Vikasit Code Zen 并点击 Create API Key。
执行 /connect 命令并搜索 Vikasit Code Zen。
```
/connect
```
输入你的 Vikasit Code 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

你也可以通过 Vikasit Code 配置添加更多模型。

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

你还可以通过 Vikasit Code 配置自定义模型。以下是指定提供商的示例：

{
  "$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 的 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":"..."}}' vikasit

或者添加到你的 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 vikasit
```
这些设置是可选的，应根据你的 SAP AI Core 配置进行设置。
执行 /models 命令从 40+ 个可用模型中进行选择。
```
/models
```

STACKIT

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

前往 STACKIT Portal，导航到 AI Model Serving，为你的项目创建认证令牌。

你需要先拥有 STACKIT 客户账户、用户账户和项目，才能创建认证令牌。
执行 /connect 命令并搜索 STACKIT。
```
/connect
```
输入你的 STACKIT AI Model Serving 认证令牌。
```
┌ 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 标签页中点击 Create a new API key。
执行 /connect 命令并搜索 OVHcloud AI Endpoints。
```
/connect
```
输入你的 OVHcloud AI Endpoints API 密钥。
```
┌ API key
│
│
└ enter
```
执行 /models 命令选择模型，例如 gpt-oss-120b。
```
/models
```

Scaleway

要在 Vikasit Code 中使用 Scaleway Generative APIs：

前往 Scaleway Console IAM 设置生成新的 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
```

你也可以通过 Vikasit Code 配置自定义模型。以下是指定提供商路由顺序的示例。

{
  "$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 控制台，创建账户并点击 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

你也可以通过 Vikasit Code 配置添加更多模型。

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

自定义提供商

要添加 /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 vikasit.json, check the docs for examples.
│
◇  Enter your API key
│  sk-...
└

在项目目录中创建或更新 vikasit.json 文件：
vikasit.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（适用于 /v1/chat/completions）。如果你的提供商/模型走 /v1/responses，请使用 @ai-sdk/openai。
- name：在 UI 中显示的名称。
- models：可用模型。
- options.baseURL：API 端点 URL。
- options.apiKey：可选，如果不使用 auth 认证，可直接设置 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：模型接受的最大输入 Token 数。
limit.output：模型可生成的最大 Token 数。

limit 字段让 Vikasit Code 了解你还剩余多少上下文空间。标准提供商会自动从 models.dev 拉取这些信息。

故障排除

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

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

这不适用于 Amazon Bedrock 等依赖环境变量进行认证的提供商。
对于自定义提供商，请检查 Vikasit Code 配置并确认：
- /connect 命令中使用的提供商 ID 与 Vikasit Code 配置中的 ID 一致。
- 使用了正确的 npm 包。例如，Cerebras 应使用 @ai-sdk/cerebras。对于其他所有 OpenAI 兼容的提供商，使用 @ai-sdk/openai-compatible（/v1/chat/completions）；如果模型走 /v1/responses，请使用 @ai-sdk/openai。同一 provider 混用时，可在模型下设置 provider.npm 覆盖默认值。
- options.baseURL 字段中的 API 端点地址正确。