clone/opencode
1
0
Fork 0
mirror of https://github.com/anomalyco/opencode.git synced 2026-04-24 06:45:22 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
129fe1e3507f014d5328122d8af875efa89cbbbc
opencode/packages/web/src/content/docs/da/providers.mdx

1944 lines
44 KiB
Plaintext
Raw Blame History

---
title: Udbydere
description: Brug en hvilken som helst LLM-udbyder i OpenCode.
---
import config from "../../../../config.mjs"
export const console = config.console
OpenCode bruger [AI SDK](https://ai-sdk.dev/) og [Models.dev](https://models.dev) til at understøtte **75+ LLM-udbydere** og understøtter kørsel af lokale modeller.
For at tilføje en udbyder skal du:
1. Tilføje API-nøglerne for udbyderen ved at bruge kommandoen `/connect`.
2. Konfigurere udbyderen i OpenCode-konfigurationen.
---
### Legitimationsoplysninger
Når du tilføjer en udbyders API-nøgler med `/connect`-kommandoen, gemmes de i `~/.local/share/opencode/auth.json`.
---
### Konfiguration
Du kan tilpasse udbyderne gennem `provider`-delen i OpenCode-konfigurationen.
---
#### Base URL
Du kan tilpasse base URL for enhver udbyder ved at angive muligheden `baseURL`. Dette er nyttigt, når du bruger proxy-tjenester eller tilpassede endpoints.
```json title="opencode.json" {6}
{
"$schema": "https://opencode.ai/config.json",
"provider": {
"anthropic": {
"options": {
"baseURL": "https://api.anthropic.com/v1"
}
}
}
}
```
---
## OpenCode Zen
OpenCode Zen er en liste over modeller leveret af OpenCode-teamet, som er blevet testet og verificeret til at fungere godt med OpenCode. [Læs mere](/docs/zen).
:::tip
Hvis du er ny, anbefaler vi at starte med OpenCode Zen.
:::
1. Kør kommandoen `/connect` i TUI, vælg opencode og gå til [opencode.ai/auth](https://opencode.ai/auth).
```txt
/connect
```
2. Log ind, tilføj dine faktureringsoplysninger og kopier API-nøglen.
3. Indsæt API-nøglen.
```txt
┌ API key
│
│
└ enter
```
4. Kør `/models` i TUI for at se listen over modeller, vi anbefaler.
```txt
/models
```
Det fungerer som alle andre udbydere i OpenCode og er helt valgfrit at bruge.
---
## OpenCode Go
OpenCode Go er en billig abonnementsplan, der giver pålidelig adgang til populære åbne kodningsmodeller leveret af OpenCode-teamet, som er testet og verificeret til at fungere godt med OpenCode.
1. Kør kommandoen `/connect` i TUI, vælg `OpenCode Go`, og gå til [opencode.ai/auth](https://opencode.ai/zen).
```txt
/connect
```
2. Log ind, tilføj dine faktureringsoplysninger og kopier din API-nøgle.
3. Indsæt din API-nøgle.
```txt
┌ API key
│
│
└ enter
```
4. Kør `/models` i TUI for at se listen over modeller, vi anbefaler.
```txt
/models
```
Det fungerer som alle andre udbydere i OpenCode og er helt valgfrit at bruge.
---
## Katalog
Lad os se på nogle af udbyderne i detaljer. Hvis du vil tilføje en udbyder til listen, er du velkommen til at åbne en PR.
:::note
Ser du ikke en udbyder her? Indsend en PR.
:::
---
### 302.AI
1. Gå til [302.AI-konsollen](https://302.ai/), opret en konto og generer en API-nøgle.
2. Kør kommandoen `/connect` og søg efter **302.AI**.
```txt
/connect
```
3. Indtast 302.AI API-nøglen.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model.
```txt
/models
```
---
### Amazon Bedrock
Sådan bruger du Amazon Bedrock med OpenCode:
1. Gå til **modelkataloget** i Amazon Bedrock-konsollen og anmod om adgang til de modeller, du ønsker.
:::tip
Du skal have adgang til modellen du ønsker i Amazon Bedrock.
:::
2. **Konfigurer godkendelse** ved at bruge en af følgende metoder:
#### Miljøvariabler (hurtigstart)
Angiv en af disse miljøvariabler, mens du kører opencode:
```bash
# 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
```
Eller tilføj dem til din bash-profil:
```bash title="~/.bash_profile"
export AWS_PROFILE=my-dev-profile
export AWS_REGION=us-east-1
```
#### Konfigurationsfil (anbefalet)
For projektspecifik eller vedvarende konfiguration, brug `opencode.json`:
```json title="opencode.json"
{
"$schema": "https://opencode.ai/config.json",
"provider": {
"amazon-bedrock": {
"options": {
"region": "us-east-1",
"profile": "my-aws-profile"
}
}
}
}
```
**Tilgængelige muligheder:**
- `region` - AWS region (f.eks. `us-east-1`, `eu-west-1`)
- `profile` - AWS navngivet profil fra `~/.aws/credentials`
- `endpoint` - Brugerdefineret endpoint URL for VPC endpoints (alias for generisk `baseURL`-mulighed)
:::tip
Konfigurationsfil-muligheder har forrang over miljøvariabler.
:::
#### Avanceret: VPC Endpoints
Hvis du bruger VPC endpoints for Bedrock:
```json title="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
Muligheden `endpoint` er et alias for den generiske mulighed `baseURL`, der bruger AWS-specifik terminologi. Hvis både `endpoint` og `baseURL` er specificeret, har `endpoint` forrang.
:::
#### Godkendelsesmetoder
- **`AWS_ACCESS_KEY_ID` / `AWS_SECRET_ACCESS_KEY`**: Opret en IAM-bruger og generer adgangsnøgler i AWS-konsollen
- **`AWS_PROFILE`**: Brug navngivne profiler fra `~/.aws/credentials`. Konfigurer først med `aws configure --profile my-profile` eller `aws sso login`
- **`AWS_BEARER_TOKEN_BEDROCK`**: Generer langsigtede API-nøgler fra Amazon Bedrock-konsollen
- **`AWS_WEB_IDENTITY_TOKEN_FILE` / `AWS_ROLE_ARN`**: For EKS IRSA (IAM roller for tjenestekonti) eller andre Kubernetes-miljøer med OIDC føderation. Disse miljøvariabler injiceres automatisk af Kubernetes, når du bruger tjenestekontokommentarer.
#### Godkendelsesprioritet
Amazon Bedrock bruger følgende godkendelsesprioritet:
1. **Bearer Token** - `AWS_BEARER_TOKEN_BEDROCK` miljøvariabel eller token fra kommandoen `/connect`
2. **AWS legitimationskæde** - profil, adgangsnøgler, delte legitimationsoplysninger, IAM roller, webidentitetstokens (EKS IRSA), instansmetadata
:::note
Når et bearer token er angivet (via `/connect` eller `AWS_BEARER_TOKEN_BEDROCK`), har det forrang over alle AWS godkendelsesmetoder inklusiv konfigurerede profiler.
:::
3. Kør kommandoen `/models` for at vælge den model, du ønsker.
```txt
/models
```
:::note
For brugerdefinerede inferensprofiler, brug modellen og udbydernavnet i nøglen og sæt egenskaben `id` til arn. Dette sikrer korrekt caching:
```json title="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
1. Når du har registreret dig, kør kommandoen `/connect` og vælg Anthropic.
```txt
/connect
```
2. Her kan du vælge muligheden **Claude Pro/Max**, og det vil åbne din browser og bede dig om at godkende.
```txt
┌ Select auth method
│
│ Claude Pro/Max
│ Create an API Key
│ Manually enter API Key
└
```
3. Nu skal alle de Anthropiske modeller være tilgængelige, når du bruger kommandoen `/models`.
```txt
/models
```
:::info
At bruge dit Claude Pro/Max-abonnement i OpenCode understøttes ikke officielt af [Anthropic](https://anthropic.com).
:::
##### Brug API-nøgler
Du kan også vælge **Create an API Key**, hvis du ikke har et Pro/Max-abonnement. Det åbner også din browser og beder dig logge på Anthropic og giver dig en kode, du kan indsætte i din terminal.
Eller hvis du allerede har en API-nøgle, kan du vælge **Manually enter API Key** og indsætte den i terminalen.
---
### Azure OpenAI
:::note
Hvis du støder på "Beklager, men jeg kan ikke hjælpe med den anmodning"-fejl, kan du prøve at ændre indholdsfilteret fra **DefaultV2** til **Default** i Azure-ressourcen.
:::
1. Gå til [Azure-portalen](https://portal.azure.com/) og opret en **Azure OpenAI**-ressource. Du skal bruge:
- **Ressourcenavn**: Dette bliver en del af API-endpointet (`https://RESOURCE_NAME.openai.azure.com/`)
- **API-nøgle**: Enten `KEY 1` eller `KEY 2` fra din ressource
2. Gå til [Azure AI Foundry](https://ai.azure.com/) og distribuer en model.
:::note
Distributionsnavnet skal matche modelnavnet for at opencode skal fungere korrekt.
:::
3. Kør kommandoen `/connect` og søg efter **Azure**.
```txt
/connect
```
4. Indtast API-nøglen.
```txt
┌ API key
│
│
└ enter
```
5. Angiv dit ressourcenavn som en miljøvariabel:
```bash
AZURE_RESOURCE_NAME=XXX opencode
```
Eller tilføj den til din bash-profil:
```bash title="~/.bash_profile"
export AZURE_RESOURCE_NAME=XXX
```
6. Kør kommandoen `/models` for at vælge den distribuerede model.
```txt
/models
```
---
### Azure Cognitive Services
1. Gå til [Azure-portalen](https://portal.azure.com/) og opret en **Azure OpenAI**-ressource. Du skal bruge:
- **Ressourcenavn**: Dette bliver en del af API-endpointet (`https://AZURE_COGNITIVE_SERVICES_RESOURCE_NAME.cognitiveservices.azure.com/`)
- **API-nøgle**: Enten `KEY 1` eller `KEY 2` fra din ressource
2. Gå til [Azure AI Foundry](https://ai.azure.com/) og distribuer en model.
:::note
Distributionsnavnet skal matche modelnavnet for at opencode skal fungere korrekt.
:::
3. Kør kommandoen `/connect` og søg efter **Azure Cognitive Services**.
```txt
/connect
```
4. Indtast API-nøglen.
```txt
┌ API key
│
│
└ enter
```
5. Angiv dit ressourcenavn som en miljøvariabel:
```bash
AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
```
Eller tilføj den til din bash-profil:
```bash title="~/.bash_profile"
export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX
```
6. Kør kommandoen `/models` for at vælge den distribuerede model.
```txt
/models
```
---
### Baseten
1. Gå til [Baseten](https://app.baseten.co/), opret en konto og generer en API-nøgle.
2. Kør kommandoen `/connect` og søg efter **Baseten**.
```txt
/connect
```
3. Indtast din Baseten API-nøgle.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model.
```txt
/models
```
---
### Cerebras
1. Gå til [Cerebras-konsollen](https://inference.cerebras.ai/), opret en konto og generer en API-nøgle.
2. Kør kommandoen `/connect` og søg efter **Cerebras**.
```txt
/connect
```
3. Indtast Cerebras API-nøglen.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model som _Qwen 3 Coder 480B_.
```txt
/models
```
---
### Cloudflare AI Gateway
Cloudflare AI Gateway lader dig få adgang til modeller fra OpenAI, Anthropic, Workers AI og flere gennem et samlet endpoint. Med [Unified Billing](https://developers.cloudflare.com/ai-gateway/features/unified-billing/) behøver du ikke separate API-nøgler for hver udbyder.
1. Gå til [Cloudflare-dashboardet](https://dash.cloudflare.com/), naviger til **AI** > **AI Gateway**, og opret en ny gateway.
2. Angiv konto-ID og gateway-ID som miljøvariabler.
```bash title="~/.bash_profile"
export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
export CLOUDFLARE_GATEWAY_ID=your-gateway-id
```
3. Kør kommandoen `/connect` og søg efter **Cloudflare AI Gateway**.
```txt
/connect
```
4. Indtast din Cloudflare API-token.
```txt
┌ API key
│
│
└ enter
```
Eller angiv den som en miljøvariabel.
```bash title="~/.bash_profile"
export CLOUDFLARE_API_TOKEN=your-api-token
```
5. Kør kommandoen `/models` for at vælge en model.
```txt
/models
```
Du kan også tilføje modeller gennem opencode-konfigurationen.
```json title="opencode.json"
{
"$schema": "https://opencode.ai/config.json",
"provider": {
"cloudflare-ai-gateway": {
"models": {
"openai/gpt-4o": {},
"anthropic/claude-sonnet-4": {}
}
}
}
}
```
---
### Cortecs
1. Gå til [Cortecs-konsollen](https://cortecs.ai/), opret en konto og generer en API-nøgle.
2. Kør kommandoen `/connect` og søg efter **Cortecs**.
```txt
/connect
```
3. Indtast Cortecs API-nøglen.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model som _Kimi K2 Instruct_.
```txt
/models
```
---
### DeepSeek
1. Gå til [DeepSeek-konsollen](https://platform.deepseek.com/), opret en konto og klik på **Create API Key**.
2. Kør kommandoen `/connect` og søg efter **DeepSeek**.
```txt
/connect
```
3. Indtast DeepSeek API-nøglen.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en DeepSeek-model som _DeepSeek Reasoner_.
```txt
/models
```
---
### Deep Infra
1. Gå til [Deep Infra-dashboardet](https://deepinfra.com/dash), opret en konto og generer en API-nøgle.
2. Kør kommandoen `/connect` og søg efter **Deep Infra**.
```txt
/connect
```
3. Indtast Deep Infra API-nøglen.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model.
```txt
/models
```
---
### Firmware
1. Gå til [Firmware dashboard](https://app.firmware.ai/signup), opret en konto og generer en API-nøgle.
2. Kør kommandoen `/connect` og søg efter **Firmware**.
```txt
/connect
```
3. Indtast firmware API-nøglen.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model.
```txt
/models
```
---
### Fireworks AI
1. Gå til [Fireworks AI-konsollen](https://app.fireworks.ai/), opret en konto og klik på **Create API Key**.
2. Kør kommandoen `/connect` og søg efter **Fireworks AI**.
```txt
/connect
```
3. Indtast Fireworks AI API-nøglen.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model som _Kimi K2 Instruct_.
```txt
/models
```
---
### GitLab Duo
GitLab Duo giver AI-drevet agentchat med native værktøjskaldsfunktioner gennem GitLabs anthropiske proxy.
1. Kør kommandoen `/connect` og vælg GitLab.
```txt
/connect
```
2. Vælg din godkendelsesmetode:
```txt
┌ Select auth method
│
│ OAuth (Recommended)
│ Personal Access Token
└
```
#### Brug OAuth (anbefalet)
Vælg **OAuth** og din browser åbner for autorisation.
#### Brug personlig adgangstoken
1. Gå til [GitLab User Settings > Access Tokens](https://gitlab.com/-/user_settings/personal_access_tokens)
2. Klik på **Add new token**
3. Navn: `OpenCode`, omfang: `api`
4. Kopier tokenet (starter med `glpat-`)
5. Indtast den i terminalen
3. Kør kommandoen `/models` for at se tilgængelige modeller.
```txt
/models
```
Tre Claude-baserede modeller er tilgængelige:
- **duo-chat-haiku-4-5** (standard) - Hurtige svar til hurtige opgaver
- **duo-chat-sonnet-4-5** - Balanceret ydeevne til de fleste arbejdsgange
- **duo-chat-opus-4-5** - Mest egnet til kompleks analyse
:::note
Du kan også specificere 'GITLAB_TOKEN' miljøvariabel, hvis du ikke vil
gemme tokenet i opencode auth-lagring.
:::
##### Selvhostet GitLab
:::note[overholdelsesbemærkning]
OpenCode bruger en lille model til nogle AI-opgaver som at generere sessionstitlen.
Den er konfigureret til at bruge gpt-5-nano som standard, hostet af Zen. For at låse OpenCode
til kun at bruge din egen GitLab-hostede instans, tilføj følgende i din
`opencode.json` fil. Det anbefales også at deaktivere sessionsdeling.
```json
{
"$schema": "https://opencode.ai/config.json",
"small_model": "gitlab/duo-chat-haiku-4-5",
"share": "disabled"
}
```
:::
For selvhostede GitLab-instanser:
```bash
export GITLAB_INSTANCE_URL=https://gitlab.company.com
export GITLAB_TOKEN=glpat-...
```
Hvis din instans kører en brugerdefineret AI-gateway:
```bash
GITLAB_AI_GATEWAY_URL=https://ai-gateway.company.com
```
Eller tilføj til din bash-profil:
```bash title="~/.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
Din GitLab-administrator skal aktivere følgende:
1. [Duo Agent Platform](https://docs.gitlab.com/user/duo_agent_platform/turn_on_off/) for brugeren, gruppen eller instansen
2. Funktionsflag (via Rails-konsollen):
- `agent_platform_claude_code`
- `third_party_agents_enabled`
:::
##### OAuth for selvhostede instanser
For at få Oauth til at fungere for din selvhostede instans, skal du oprette
en ny applikation (Indstillinger → Applikationer) med
callback URL `http://127.0.0.1:8080/callback` og følgende omfang:
- api (Få adgang til API på dine vegne)
- read_user (Læs din personlige information)
- read_repository (tillader skrivebeskyttet adgang til depotet)
Udsæt derefter applikations-ID som miljøvariabel:
```bash
export GITLAB_OAUTH_CLIENT_ID=your_application_id_here
```
Mere dokumentation på [opencode-gitlab-auth](https://www.npmjs.com/package/opencode-gitlab-auth) hjemmesiden.
##### Konfiguration
Tilpas gennem `opencode.json`:
```json title="opencode.json"
{
"$schema": "https://opencode.ai/config.json",
"provider": {
"gitlab": {
"options": {
"instanceUrl": "https://gitlab.com"
}
}
}
}
```
##### GitLab API-værktøjer (valgfrit, men stærkt anbefalet)
For at få adgang til GitLab-værktøjer (merge requests, problemer, pipelines, CI/CD, etc.):
```json title="opencode.json"
{
"$schema": "https://opencode.ai/config.json",
"plugin": ["opencode-gitlab-plugin"]
}
```
Denne plugin giver omfattende GitLab-repository-administrationsfunktioner, inklusiv MR-anmeldelser, problemsporing, pipeline-overvågning og mere.
---
### GitHub Copilot
Sådan bruger du GitHub Copilot-abonnementet med OpenCode:
:::note
Nogle modeller kan kræve et [Pro+
abonnement](https://github.com/features/copilot/plans) at bruge.
Nogle modeller skal aktiveres manuelt i [GitHub Copilot-indstillingerne](https://docs.github.com/en/copilot/how-tos/use-ai-models/configure-access-to-ai-models#setup-for-individual-use).
:::
1. Kør kommandoen `/connect` og søg efter GitHub Copilot.
```txt
/connect
```
2. Naviger til [github.com/login/device](https://github.com/login/device) og indtast koden.
```txt
┌ Login with GitHub Copilot
│
│ https://github.com/login/device
│
│ Enter code: 8F43-6FCF
│
│ Waiting for authorization...
```
3. Kør nu kommandoen `/models` for at vælge modellen du ønsker.
```txt
/models
```
---
### Google Vertex AI
Sådan bruger du Google Vertex AI med OpenCode:
1. Gå til **Model Garden** i Google Cloud Console og tjek
modeller tilgængelig i din region.
:::note
Du skal have et Google Cloud-projekt med Vertex AI API aktiveret.
:::
2. Angiv de nødvendige miljøvariabler:
- `GOOGLE_CLOUD_PROJECT`: Dit Google Cloud-projekt ID
- `VERTEX_LOCATION` (valgfrit): Regionen for Vertex AI (standard til `global`)
- Godkendelse (vælg en):
- `GOOGLE_APPLICATION_CREDENTIALS`: Sti til tjenestekontoens JSON-nøglefil
- Godkend med gcloud CLI: `gcloud auth application-default login`
Sæt dem mens du kører opencode.
```bash
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id opencode
```
Eller tilføj dem til din bash-profil.
```bash title="~/.bash_profile"
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
export GOOGLE_CLOUD_PROJECT=your-project-id
export VERTEX_LOCATION=global
```
:::tip
`global`-regionen forbedrer tilgængeligheden og reducerer fejl uden ekstra omkostninger. Brug regionale endpoints (f.eks. `us-central1`) for krav til dataophold. [Læs mere](https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/use-partner-models#regional_and_global_endpoints)
:::
3. Kør kommandoen `/models` for at vælge modellen du ønsker.
```txt
/models
```
---
### Groq
1. Gå til [Groq-konsollen](https://console.groq.com/), klik på **Create API Key**, og kopier nøglen.
2. Kør kommandoen `/connect` og søg efter Groq.
```txt
/connect
```
3. Indtast API-nøglen for udbyderen.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge den du ønsker.
```txt
/models
```
---
### Hugging Face
[Hugging Face Inference Providers](https://huggingface.co/docs/inference-providers) giver adgang til åbne modeller som støttes af 17+ udbydere.
1. Gå til [Hugging Face-indstillinger](https://huggingface.co/settings/tokens/new?ownUserPermissions=inference.serverless.write&tokenType=fineGrained) for at oprette et token med tilladelse til at kalde inferensudbydere.
2. Kør kommandoen `/connect` og søg efter **Hugging Face**.
```txt
/connect
```
3. Indtast dit Hugging Face-token.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model som _Kimi-K2-Instruct_ eller _GLM-4.6_.
```txt
/models
```
---
### Helicone
[Helicone](https://helicone.ai) er en LLM observerbarhedsplatform som giver logning, overvågning og analyser for dine AI-applikationer. Helicone AI Gateway ruter dine anmodninger til den rigtige udbyder automatisk baseret på modellen.
1. Gå til [Helicone](https://helicone.ai), opret en konto og generer en API-nøgle fra dashboardet.
2. Kør kommandoen `/connect` og søg efter **Helicone**.
```txt
/connect
```
3. Indtast Helicone API-nøglen.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model.
```txt
/models
```
For flere udbydere og avancerede funktioner som caching og hastighedsbegrænsning, tjek [Helicone-dokumentationen](https://docs.helicone.ai).
#### Valgfrie konfigurationer
I tilfælde af at du ser en funktion eller model fra Helicone som ikke konfigureres automatisk gennem opencode, kan du altid konfigurere den selv.
Her er [Helicone's Model Directory](https://helicone.ai/models), du skal bruge denne for at hente ID'erne til de modeller du vil tilføje.
```jsonc title="~/.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",
},
},
},
},
}
```
#### Brugerdefinerede headers
Helicone understøtter tilpassede headers for funktioner som caching, brugersporing og sessionsadministration. Læg dem til din udbyderkonfiguration ved at bruge `options.headers`:
```jsonc title="~/.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",
},
},
},
},
}
```
##### Sessionssporing
Helicones [Sessions](https://docs.helicone.ai/features/sessions) funktion lader dig gruppe relaterede LLM anmodninger sammen. Brug [opencode-helicone-session](https://github.com/H2Shami/opencode-helicone-session) plugin for automatisk at logge hver OpenCode-samtale som en session i Helicone.
```bash
npm install -g opencode-helicone-session
```
Tilføj den til din konfiguration.
```json title="opencode.json"
{
"plugin": ["opencode-helicone-session"]
}
```
Programmatisk injicerer `Helicone-Session-Id` og `Helicone-Session-Name` headers i dine anmodninger. På Helicones Sessions-side vil du se hver OpenCode-samtale opført som en separat session.
##### Almindelige Helicone-headers
| Header | Beskrivelse |
| -------------------------- | ------------------------------------------------------------------------- |
| `Helicone-Cache-Enabled` | Aktiver respons-caching (`true`/`false`) |
| `Helicone-User-Id` | Spor beregninger efter bruger |
| `Helicone-Property-[Name]` | Tilføj egendefinerede egenskaber (f.eks. `Helicone-Property-Environment`) |
| `Helicone-Prompt-Id` | Knyt anmodninger til prompt-versioner |
Se [Helicone Header Directory](https://docs.helicone.ai/helicone-headers/header-directory) for alle tilgængelige headers.
---
### llama.cpp
Du kan konfigurere opencode til at bruge lokale modeller gennem [llama.cpps](https://github.com/ggml-org/llama.cpp) llama-server-værktøj
```json title="opencode.json" "llama.cpp" {5, 6, 8, 10-15}
{
"$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
}
}
}
}
}
}
```
I dette eksempel:
- `llama.cpp` er den tilpassede udbyder ID. Dette kan være hvilken som helst streng du vil.
- `npm` specificerer pakken som skal bruges for denne udbyder. Her bruges `@ai-sdk/openai-compatible` for enhver OpenAI-kompatibel API.
- `name` er visningsnavnet for udbyderen i UI.
- `options.baseURL` er endpointet for den lokale server.
- `models` er et kort over model-ID'er til deres konfigurationer. Modelnavnet vil vises i modelvalglisten.
---
### IO.NET
IO.NET tilbyder 17 modeller optimeret for forskellige brugstilfælde:
1. Gå til [IO.NET-konsollen](https://ai.io.net/), opret en konto og generer en API-nøgle.
2. Kør kommandoen `/connect` og søg efter **IO.NET**.
```txt
/connect
```
3. Indtast nøglen IO.NET API.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model.
```txt
/models
```
---
### LM Studio
Du kan konfigurere opencode til at bruge lokale modeller gennem LM Studio.
```json title="opencode.json" "lmstudio" {5, 6, 8, 10-14}
{
"$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)"
}
}
}
}
}
```
I dette eksempel:
- `lmstudio` er den tilpassede udbyder ID. Dette kan være hvilken som helst streng du vil.
- `npm` specificerer pakken som skal bruges for denne udbyder. Her bruges `@ai-sdk/openai-compatible` for enhver OpenAI-kompatibel API.
- `name` er visningsnavnet for udbyderen i UI.
- `options.baseURL` er endpointet for den lokale server.
- `models` er et kort over model-ID'er til deres konfigurationer. Modelnavnet vil vises i modelvalglisten.
---
### Moonshot AI
Sådan bruger du Kimi K2 fra Moonshot AI:
1. Gå til [Moonshot AI-konsollen](https://platform.moonshot.ai/console), opret en konto og klik på **Create API Key**.
2. Kør kommandoen `/connect` og søg efter **Moonshot AI**.
```txt
/connect
```
3. Indtast Moonshot API-nøglen.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge _Kimi K2_.
```txt
/models
```
---
### MiniMax
1. Gå til [MiniMax API-konsollen](https://platform.minimax.io/login), opret en konto og generer en API-nøgle.
2. Kør kommandoen `/connect` og søg efter **MiniMax**.
```txt
/connect
```
3. Indtast MiniMax API-nøglen.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model som _M2.1_.
```txt
/models
```
---
### Nebius Token Factory
1. Gå til [Nebius Token Factory-konsollen](https://tokenfactory.nebius.com/), opret en konto og klik på **Add Key**.
2. Kør kommandoen `/connect` og søg efter **Nebius Token Factory**.
```txt
/connect
```
3. Indtast Nebius Token Factory API-nøglen.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model som _Kimi K2 Instruct_.
```txt
/models
```
---
### Ollama
Du kan konfigurere opencode til at bruge lokale modeller gennem Ollama.
:::tip
Ollama kan automatisk konfigurere sig selv for OpenCode. Se [Ollama-integrationsdokumenterne](https://docs.ollama.com/integrations/opencode) for detaljer.
:::
```json title="opencode.json" "ollama" {5, 6, 8, 10-14}
{
"$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"
}
}
}
}
}
```
I dette eksempel:
- `ollama` er den tilpassede udbyder ID. Dette kan være hvilken som helst streng du vil.
- `npm` specificerer pakken som skal bruges for denne udbyder. Her bruges `@ai-sdk/openai-compatible` for enhver OpenAI-kompatibel API.
- `name` er visningsnavnet for udbyderen i UI.
- `options.baseURL` er endpointet for den lokale server.
- `models` er et kort over model-ID'er til deres konfigurationer. Modelnavnet vil vises i modelvalglisten.
:::tip
Hvis værktøjskald ikke fungerer, prøv at øge `num_ctx` i Ollama. Start omkring 16k - 32k.
:::
---
### Ollama Cloud
Sådan bruger du Ollama Cloud med OpenCode:
1. Gå til [https://ollama.com/](https://ollama.com/) og log på eller opret en konto.
2. Naviger til **Settings** > **Keys** og klik på **Add API Key** for at generere en ny API-nøgle.
3. Kopier API-nøglen til brug i OpenCode.
4. Kør kommandoen `/connect` og søg efter **Ollama Cloud**.
```txt
/connect
```
5. Indtast din Ollama Cloud API-nøgle.
```txt
┌ API key
│
│
└ enter
```
6. **Vigtigt**: Før du bruger skymodeller i OpenCode, skal du hente modelinformationen lokalt:
```bash
ollama pull gpt-oss:20b-cloud
```
7. Kør kommandoen `/models` for at vælge din Ollama Cloud-model.
```txt
/models
```
---
### OpenAI
Vi anbefaler at du registrerer dig for [ChatGPT Plus eller Pro](https://chatgpt.com/pricing).
1. Når du har registreret dig, kør kommandoen `/connect` og vælg OpenAI.
```txt
/connect
```
2. Her kan du vælge muligheden **ChatGPT Plus/Pro** og det åbner din browser
og beder dig om at godkende.
```txt
┌ Select auth method
│
│ ChatGPT Plus/Pro
│ Manually enter API Key
└
```
3. Nu skal alle OpenAI-modellerne være tilgængelige, når du bruger kommandoen `/models`.
```txt
/models
```
##### Brug API-nøgler
Hvis du allerede har en API-nøgle, kan du vælge **Manually enter API Key** og indsætte den i terminalen.
---
### OpenCode Zen
OpenCode Zen er en liste over testede og verificerede modeller leveret af OpenCode-teamet. [Læs mere](/docs/zen).
1. Log på **<a href={console}>OpenCode Zen</a>** og klik på **Create API Key**.
2. Kør kommandoen `/connect` og søg efter **OpenCode Zen**.
```txt
/connect
```
3. Indtast OpenCode API-nøglen.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model som _Qwen 3 Coder 480B_.
```txt
/models
```
---
### OpenRouter
1. Gå til [OpenRouter-dashboardet](https://openrouter.ai/settings/keys), klik på **Create API Key**, og kopier nøglen.
2. Kør kommandoen `/connect` og søg efter OpenRouter.
```txt
/connect
```
3. Indtast API-nøglen for udbyderen.
```txt
┌ API key
│
│
└ enter
```
4. Mange OpenRouter-modeller er forudindlæst som standard, kør kommandoen `/models` for at vælge den du ønsker.
```txt
/models
```
Du kan også tilføje flere modeller gennem opencode-konfigurationen.
```json title="opencode.json" {6}
{
"$schema": "https://opencode.ai/config.json",
"provider": {
"openrouter": {
"models": {
"somecoolnewmodel": {}
}
}
}
}
```
5. Du kan også tilpasse dem gennem opencode-konfigurationen. Her er et eksempel på at specificere en udbyder
```json title="opencode.json"
{
"$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 giver adgang til 40+ modeller fra OpenAI, Anthropic, Google, Amazon, Meta, Mistral og AI21 gennem en samlet platform.
1. Gå til din [SAP BTP Cockpit](https://account.hana.ondemand.com/), naviger til din SAP AI kerne-tjenesteinstans, og opret en tjenestenøgle.
:::tip
Tjenestenøglen er et JSON-objekt som indeholder `clientid`, `clientsecret`, `url` og `serviceurls.AI_API_URL`. Du finder din AI-kerneinstans under **Services** > **Instances and Subscriptions** i BTP cockpittet.
:::
2. Kør kommandoen `/connect` og søg efter **SAP AI Core**.
```txt
/connect
```
3. Indtast tjenestenøglen JSON.
```txt
┌ Service key
│
│
└ enter
```
Eller angiv miljøvariablen `AICORE_SERVICE_KEY`:
```bash
AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}' opencode
```
Eller tilføj den til din bash-profil:
```bash title="~/.bash_profile"
export AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}'
```
4. Angiv eventuelt deployment-ID og ressourcegruppe:
```bash
AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode
```
:::note
Disse indstillinger er valgfrie og bør konfigureres i henhold til SAP AI kerne-opsætningen.
:::
5. Kør kommandoen `/models` for at vælge fra 40+ tilgængelige modeller.
```txt
/models
```
---
### STACKIT
STACKIT AI Model Serving leverer fuldt administreret suverænt hostingmiljø til AI-modeller, med fokus på LLM'er som Llama, Mistral og Qwen, med maksimal datasuverænitet på europæisk infrastruktur.
1. Gå til [STACKIT Portal](https://portal.stackit.cloud), naviger til **AI Model Serving**, og opret en auth-token til dit projekt.
:::tip
Du skal have en STACKIT-kundekonto, brugerkonto og projekt, før du opretter auth-tokens.
:::
2. Kør kommandoen `/connect` og søg efter **STACKIT**.
```txt
/connect
```
3. Indtast din STACKIT AI Model Serving auth-token.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge fra tilgængelige modeller som _Qwen3-VL 235B_ eller _Llama 3.3 70B_.
```txt
/models
```
---
### OVHcloud AI Endpoints
1. Gå til [OVHcloud-panelet](https://ovh.com/manager). Naviger til `Public Cloud`-delen, `AI & Machine Learning` > `AI Endpoints` og i `API Keys`-fanen klikker du på **Opret en ny API-nøgle**.
2. Kør kommandoen `/connect` og søg efter **OVHcloud AI Endpoints**.
```txt
/connect
```
3. Indtast OVHcloud AI Endpoints API-nøgle.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model som _gpt-oss-120b_.
```txt
/models
```
---
### Scaleway
Sådan bruger du [Scaleway Generative APIs](https://www.scaleway.com/en/docs/generative-apis/) med OpenCode:
1. Gå til [Scaleway Console IAM indstillinger](https://console.scaleway.com/iam/api-keys) for at generere en ny API-nøgle.
2. Kør kommandoen `/connect` og søg efter **Scaleway**.
```txt
/connect
```
3. Indtast Scaleway API-nøglen.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model som _devstral-2-123b-instruct-2512_ eller _gpt-oss-120b_.
```txt
/models
```
---
### Together AI
1. Gå til [Together AI-konsollen](https://api.together.ai), opret en konto og klik på **Add Key**.
2. Kør kommandoen `/connect` og søg efter **Together AI**.
```txt
/connect
```
3. Indtast Together AI API-nøglen.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model som _Kimi K2 Instruct_.
```txt
/models
```
---
### Venice AI
1. Gå til [Venice AI-konsollen](https://venice.ai), opret en konto og generer en API-nøgle.
2. Kør kommandoen `/connect` og søg efter **Venice AI**.
```txt
/connect
```
3. Indtast Venice AI API-nøglen.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model som _Llama 3.3 70B_.
```txt
/models
```
---
### Vercel AI Gateway
Vercel AI Gateway lader dig få adgang til modeller fra OpenAI, Anthropic, Google, xAI og mere gennem et samlet endpoint. Modeller tilbydes til listepris uden påslag.
1. Gå til [Vercel dashboard](https://vercel.com/), naviger til fanen **AI Gateway**, og klik på **API Keys** for at oprette en ny API-nøgle.
2. Kør kommandoen `/connect` og søg efter **Vercel AI Gateway**.
```txt
/connect
```
3. Indtast Vercel AI Gateway API-nøgle.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model.
```txt
/models
```
Du kan også tilpasse modeller gennem opencode-konfigurationen. Her er et eksempel på specificering af udbyder-rutingsrækkefølge.
```json title="opencode.json"
{
"$schema": "https://opencode.ai/config.json",
"provider": {
"vercel": {
"models": {
"anthropic/claude-sonnet-4": {
"options": {
"order": ["anthropic", "vertex"]
}
}
}
}
}
}
```
Nogle nyttige rutealternativer:
| Alternativ | Beskrivelse |
| ------------------- | -------------------------------------------------------- |
| `order` | Providersekvens for at prøve |
| `only` | Begræns til specifikke udbydere |
| `zeroDataRetention` | Brug kun udbydere med nul retningslinjer for datalagring |
---
### xAI
1. Gå til [xAI-konsollen](https://console.x.ai/), opret en konto og generer en API-nøgle.
2. Kør kommandoen `/connect` og søg efter **xAI**.
```txt
/connect
```
3. Indtast xAI API-nøglen.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model som _Grok Beta_.
```txt
/models
```
---
### Z.AI
1. Gå til [Z.AI API-konsollen](https://z.ai/manage-apikey/apikey-list), opret en konto og klik på **Create new API Key**.
2. Kør kommandoen `/connect` og søg efter **Z.AI**.
```txt
/connect
```
Hvis du abonnerer på **GLM Coding Plan**, vælg **Z.AI Coding Plan**.
3. Indtast Z.AI API-nøglen.
```txt
┌ API key
│
│
└ enter
```
4. Kør kommandoen `/models` for at vælge en model som _GLM-4.7_.
```txt
/models
```
---
### ZenMux
1. Gå til [ZenMux-dashboardet](https://zenmux.ai/settings/keys), klik på **Create API Key**, og kopier nøglen.
2. Kør kommandoen `/connect` og søg efter ZenMux.
```txt
/connect
```
3. Indtast API-nøglen for udbyderen.
```txt
┌ API key
│
│
└ enter
```
4. Mange ZenMux-modeller er forudindlæst som standard, kør kommandoen `/models` for at vælge den du ønsker.
```txt
/models
```
Du kan også tilføje flere modeller gennem opencode-konfigurationen.
```json title="opencode.json" {6}
{
"$schema": "https://opencode.ai/config.json",
"provider": {
"zenmux": {
"models": {
"somecoolnewmodel": {}
}
}
}
}
```
---
## Brugerdefineret udbyder
Sådan tilføjer du en **OpenAI-kompatibel** udbyder som ikke er opført i `/connect`-kommandoen:
:::tip
Du kan bruge hvilken som helst OpenAI-kompatibel udbyder med opencode. De fleste moderne AI-udbydere tilbyder OpenAI-kompatible API'er.
:::
1. Kør kommandoen `/connect` og rul ned til **Other**.
```bash
$ /connect
┌ Add credential
│
◆ Select provider
│ ...
│ ● Other
└
```
2. Indtast et unikt ID for udbyderen.
```bash
$ /connect
┌ Add credential
│
◇ Enter provider id
│ myprovider
└
```
:::note
Vælg et mindeværdigt ID, du vil bruge dette i din konfigurationsfil.
:::
3. Indtast API-nøglen for udbyderen.
```bash
$ /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-...
└
```
4. Opret eller opdater `opencode.json`-filen i projektkataloget:
```json title="opencode.json" ""myprovider"" {5-15}
{
"$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"
}
}
}
}
}
```
Her er konfigurationsmulighederne:
- **npm**: AI SDK pakke at bruge, `@ai-sdk/openai-compatible` for OpenAI-kompatible udbydere
- **name**: Visningsnavn i UI.
- **models**: Tilgængelige modeller.
- **options.baseURL**: API endpoint URL.
- **options.apiKey**: Angiv API-nøglen hvis du ikke bruger auth.
- **options.headers**: Angiv egendefinerede headers.
Mere om de avancerede muligheder i eksemplet nedenfor.
5. Kør kommandoen `/models` og din egendefinerede udbyder og modeller vil vises i udvalgslisten.
---
##### Eksempel
Her er et eksempel på indstilling af mulighederne `apiKey`, `headers` og model `limit`.
```json title="opencode.json" {9,11,17-20}
{
"$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
}
}
}
}
}
}
```
Konfigurationsdetaljer:
- **apiKey**: Angiv med `env` variabel syntaks, [læs mere](/docs/config#env-vars).
- **headers**: Egendefinerede headers sendt med hver anmodning.
- **limit.context**: Maksimalt input-tokens som modellen accepterer.
- **limit.output**: Maksimalt antal tokens modellen kan generere.
`limit`-felterne lader OpenCode forstå hvor meget kontekst du har tilbage. Standardudbydere henter disse automatisk fra models.dev.
---
## Fejlfinding
Hvis du har problemer med at konfigurere en udbyder, tjek følgende:
1. **Tjek godkendelsesopsætningen**: Kør `opencode auth list` for at se om legitimationsoplysningerne
for udbyderen er tilføjet til din konfiguration.
Dette gælder ikke udbydere som Amazon Bedrock, som er afhængige af miljøvariabler for godkendelse.
2. For tilpassede udbydere, tjek opencode-konfigurationen og:
- Sørg for at udbyderens ID som bruges i `/connect`-kommandoen matcher ID i opencode-konfigurationen.
- Den rigtige npm-pakke bruges for udbyderen. Brug for eksempel `@ai-sdk/cerebras` for Cerebras. Og for alle andre OpenAI-kompatible udbydere, brug `@ai-sdk/openai-compatible`.
- Kontroller at korrekt API-endpoint er brugt i `options.baseURL`-feltet.
Reference in New Issue View Git Blame Copy Permalink