1890 lines
44 KiB
Plaintext
1890 lines
44 KiB
Plaintext
---
|
||
title: Leverandører
|
||
description: Bruke en hvilken som helst LLM-leverandør i OpenCode.
|
||
---
|
||
|
||
import config from "../../../../config.mjs"
|
||
export const console = config.console
|
||
|
||
OpenCode bruker [AI SDK](https://ai-sdk.dev/) og [Models.dev](https://models.dev) for å støtte **75+ LLM leverandører** og den støtter kjøring av lokale modeller.
|
||
|
||
For å legge til en leverandør må du:
|
||
|
||
1. Legg til API-nøklene for leverandøren ved å bruke kommandoen `/connect`.
|
||
2. Konfigurer leverandøren i OpenCode-konfigurasjonen.
|
||
|
||
---
|
||
|
||
### Legitimasjon
|
||
|
||
Når du legger til en leverandørs API-nøkler med `/connect`-kommandoen, lagres de
|
||
i `~/.local/share/opencode/auth.json`.
|
||
|
||
---
|
||
|
||
### Konfig
|
||
|
||
Du kan tilpasse leverandørene gjennom `provider`-delen i OpenCode
|
||
konfig.
|
||
|
||
---
|
||
|
||
#### Base URL
|
||
|
||
Du kan tilpasse basen URL for enhver leverandør ved å angi alternativet `baseURL`. Dette er nyttig når du bruker proxy-tjenester eller tilpassede endepunkter.
|
||
|
||
```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 levert av OpenCode-teamet som har vært
|
||
testet og verifisert for å fungere godt med OpenCode. [Finn ut mer](/docs/zen).
|
||
|
||
:::tip
|
||
Hvis du er ny, anbefaler vi å starte med OpenCode Zen.
|
||
:::
|
||
|
||
1. Kjør kommandoen `/connect` i TUI, velg opencode og gå til [opencode.ai/auth](https://opencode.ai/auth).
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
2. Logg på, legg til faktureringsdetaljene dine og kopier API-nøkkelen.
|
||
|
||
3. Lim inn API-nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør `/models` i TUI for å se listen over modeller vi anbefaler.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
Det fungerer som alle andre leverandører i OpenCode og er helt valgfritt å bruke.
|
||
|
||
---
|
||
|
||
## Katalog
|
||
|
||
La oss se på noen av leverandørene i detalj. Hvis du vil legge til en leverandør til
|
||
liste, åpne gjerne en PR.
|
||
|
||
:::note
|
||
Ser du ikke en leverandør her? Send inn en PR.
|
||
:::
|
||
|
||
---
|
||
|
||
### 302.AI
|
||
|
||
1. Gå over til [302.AI-konsollen](https://302.ai/), opprett en konto og generer en API-nøkkel.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **302.AI**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn 302.AI API-nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Amazonas grunnfjell
|
||
|
||
Slik bruker du Amazon Bedrock med OpenCode:
|
||
|
||
1. Gå over til **modellkatalogen** i Amazon Bedrock-konsollen og be om
|
||
tilgang til modellene du ønsker.
|
||
|
||
:::tip
|
||
Du må ha tilgang til modellen du ønsker i Amazon Bedrock.
|
||
:::
|
||
|
||
2. **Konfigurer autentisering** ved å bruke en av følgende metoder:
|
||
|
||
#### Miljøvariabler (hurtigstart)
|
||
|
||
Angi en av disse miljøvariablene mens du kjø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 legg dem til bash-profilen din:
|
||
|
||
```bash title="~/.bash_profile"
|
||
export AWS_PROFILE=my-dev-profile
|
||
export AWS_REGION=us-east-1
|
||
```
|
||
|
||
#### Konfigurasjonsfil (anbefalt)
|
||
|
||
For prosjektspesifikk eller vedvarende konfigurasjon, bruk `opencode.json`:
|
||
|
||
```json title="opencode.json"
|
||
{
|
||
"$schema": "https://opencode.ai/config.json",
|
||
"provider": {
|
||
"amazon-bedrock": {
|
||
"options": {
|
||
"region": "us-east-1",
|
||
"profile": "my-aws-profile"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
**Tilgjengelige alternativer:**
|
||
- `region` - AWS region (f.eks. `us-east-1`, `eu-west-1`)
|
||
- `profile` - AWS navngitt profil fra `~/.aws/credentials`
|
||
- `endpoint` - Egendefinert endepunkt URL for VPC endepunkter (alias for generisk `baseURL`-alternativ)
|
||
|
||
:::tip
|
||
Alternativer for konfigurasjonsfil har forrang over miljøvariabler.
|
||
:::
|
||
|
||
#### Avansert: VPC Sluttpunkter
|
||
|
||
Hvis du bruker VPC endepunkter for Berggrunn:
|
||
|
||
```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
|
||
Alternativet `endpoint` er et alias for det generiske alternativet `baseURL`, ved å bruke AWS-spesifikk terminologi. Hvis både `endpoint` og `baseURL` er spesifisert, har `endpoint` forrang.
|
||
:::
|
||
|
||
#### Autentiseringsmetoder
|
||
- **`AWS_ACCESS_KEY_ID` / `AWS_SECRET_ACCESS_KEY`**: Opprett en IAM-bruker og generer tilgangsnøkler i AWS-konsollen
|
||
- **`AWS_PROFILE`**: Bruk navngitte profiler fra `~/.aws/credentials`. Konfigurer først med `aws configure --profile my-profile` eller `aws sso login`
|
||
- **`AWS_BEARER_TOKEN_BEDROCK`**: Generer langsiktige API-nøkler fra Amazon Bedrock-konsollen
|
||
- **`AWS_WEB_IDENTITY_TOKEN_FILE` / `AWS_ROLE_ARN`**: For EKS IRSA (IAM roller for tjenestekontoer) eller andre Kubernetes-miljøer med OIDC føderasjon. Disse miljøvariablene injiseres automatisk av Kubernetes når du bruker tjenestekontokommentarer.
|
||
|
||
#### Autentiseringsprioritet
|
||
|
||
Amazon Bedrock bruker følgende autentiseringsprioritet:
|
||
1. **Bearer Token** - `AWS_BEARER_TOKEN_BEDROCK` miljøvariabel eller token fra kommandoen `/connect`
|
||
2. **AWS legitimasjonskjede** - profil, tilgangsnøkler, delt legitimasjon, IAM roller, nettidentitetstokener (EKS IRSA), forekomstmetadata
|
||
|
||
:::note
|
||
Når et bærertoken er angitt (via `/connect` eller `AWS_BEARER_TOKEN_BEDROCK`), har det forrang over alle AWS legitimasjonsmetoder inkludert konfigurerte profiler.
|
||
:::
|
||
|
||
3. Kjør kommandoen `/models` for å velge modellen du ønsker.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
:::note
|
||
For egendefinerte slutningsprofiler, bruk modellen og leverandørnavnet i nøkkelen og sett egenskapen `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"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
:::
|
||
|
||
---
|
||
|
||
### Antropisk
|
||
|
||
1. Når du har registrert deg, kjør kommandoen `/connect` og velg Antropisk.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
2. Her kan du velge alternativet **Claude Pro/Max** og det vil åpne nettleseren din
|
||
og ber deg om å autentisere.
|
||
|
||
```txt
|
||
┌ Select auth method
|
||
│
|
||
│ Claude Pro/Max
|
||
│ Create an API Key
|
||
│ Manually enter API Key
|
||
└
|
||
```
|
||
|
||
3. Nå skal alle de antropiske modellene være tilgjengelige når du bruker kommandoen `/models`.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
:::info
|
||
Å bruke Claude Pro/Max-abonnementet ditt i OpenCode støttes ikke offisielt av [Anthropic](https://anthropic.com).
|
||
:::
|
||
|
||
##### Bruke API-tastene
|
||
|
||
Du kan også velge **Opprett en API nøkkel** hvis du ikke har et Pro/Max-abonnement. Den åpner også nettleseren din og ber deg logge på Anthropic og gi deg en kode du kan lime inn i terminalen din.
|
||
|
||
Eller hvis du allerede har en API-nøkkel, kan du velge **Angi API-nøkkel manuelt** og lime den inn i terminalen.
|
||
|
||
---
|
||
|
||
### Azure OpenAI
|
||
|
||
:::note
|
||
Hvis du støter på «Beklager, men jeg kan ikke hjelpe med den forespørselen»-feil, kan du prøve å endre innholdsfilteret fra **DefaultV2** til **Default** i Azure-ressursen.
|
||
:::
|
||
|
||
1. Gå over til [Azure-portalen](https://portal.azure.com/) og lag en **Azure OpenAI**-ressurs. Du trenger:
|
||
- **Ressursnavn**: Dette blir en del av API-endepunktet (`https://RESOURCE_NAME.openai.azure.com/`)
|
||
- **API nøkkel**: Enten `KEY 1` eller `KEY 2` fra ressursen din
|
||
|
||
2. Gå til [Azure AI Foundry](https://ai.azure.com/) og distribuer en modell.
|
||
|
||
:::note
|
||
Distribusjonsnavnet må samsvare med modellnavnet for at opencode skal fungere skikkelig.
|
||
:::
|
||
|
||
3. Kjør kommandoen `/connect` og søk etter **Azure**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
4. Skriv inn API-nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
5. Angi ressursnavnet ditt som en miljøvariabel:
|
||
|
||
```bash
|
||
AZURE_RESOURCE_NAME=XXX opencode
|
||
```
|
||
|
||
Eller legg den til bash-profilen din:
|
||
|
||
```bash title="~/.bash_profile"
|
||
export AZURE_RESOURCE_NAME=XXX
|
||
```
|
||
|
||
6. Kjør kommandoen `/models` for å velge den distribuerte modellen.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Azure Cognitive Services
|
||
|
||
1. Gå over til [Azure-portalen](https://portal.azure.com/) og lag en **Azure OpenAI**-ressurs. Du trenger:
|
||
- **Ressursnavn**: Dette blir en del av API-endepunktet (`https://AZURE_COGNITIVE_SERVICES_RESOURCE_NAME.cognitiveservices.azure.com/`)
|
||
- **API nøkkel**: Enten `KEY 1` eller `KEY 2` fra ressursen din
|
||
|
||
2. Gå til [Azure AI Foundry](https://ai.azure.com/) og distribuer en modell.
|
||
|
||
:::note
|
||
Distribusjonsnavnet må samsvare med modellnavnet for at opencode skal fungere skikkelig.
|
||
:::
|
||
|
||
3. Kjør kommandoen `/connect` og søk etter **Azure Cognitive Services**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
4. Skriv inn API-nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
5. Angi ressursnavnet ditt som en miljøvariabel:
|
||
|
||
```bash
|
||
AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
|
||
```
|
||
|
||
Eller legg den til bash-profilen din:
|
||
|
||
```bash title="~/.bash_profile"
|
||
export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX
|
||
```
|
||
|
||
6. Kjør kommandoen `/models` for å velge den distribuerte modellen.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Baseten
|
||
|
||
1. Gå over til [Baseten](https://app.baseten.co/), opprett en konto og generer en API nøkkel.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **Baseten**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn din Baseten API nøkkel.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Cerebras
|
||
|
||
1. Gå over til [Cerebras-konsollen](https://inference.cerebras.ai/), opprett en konto og generer en API-nøkkel.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **Cerebras**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn Cerebras API-nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell som _Qwen 3 Coder 480B_.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Cloudflare AI Gateway
|
||
|
||
Cloudflare AI Gateway lar deg få tilgang til modeller fra OpenAI, Anthropic, Workers AI og mer gjennom et enhetlig endepunkt. Med [Unified Billing](https://developers.cloudflare.com/ai-gateway/features/unified-billing/) trenger du ikke separate API-nøkler for hver leverandør.
|
||
|
||
1. Gå over til [Cloudflare-dashbordet](https://dash.cloudflare.com/), naviger til **AI** > **AI Gateway**, og lag en ny gateway.
|
||
|
||
2. Angi 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. Kjør kommandoen `/connect` og søk etter **Cloudflare AI Gateway**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
4. Skriv inn Cloudflare API-tokenet ditt.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
Eller angi den som en miljøvariabel.
|
||
|
||
```bash title="~/.bash_profile"
|
||
export CLOUDFLARE_API_TOKEN=your-api-token
|
||
```
|
||
|
||
5. Kjør kommandoen `/models` for å velge en modell.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
Du kan også legge til modeller gjennom opencode-konfigurasjonen.
|
||
|
||
```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å over til [Cortecs-konsollen](https://cortecs.ai/), opprett en konto og generer en API-nøkkel.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **Cortecs**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn Cortecs API-nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell som _Kimi K2 Instruct_.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### DeepSeek
|
||
|
||
1. Gå over til [DeepSeek-konsollen](https://platform.deepseek.com/), opprett en konto og klikk på **Opprett ny API-nøkkel**.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **DeepSeek**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn DeepSeek API-nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en DeepSeek-modell som _DeepSeek Reasoner_.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Deep Infra
|
||
|
||
1. Gå over til [Deep Infra-dashbordet](https://deepinfra.com/dash), opprett en konto og generer en API-nøkkel.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **Deep Infra**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn Deep Infra API nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Fastvare
|
||
|
||
1. Gå over til [Firmware dashboard](https://app.firmware.ai/signup), opprett en konto og generer en API nøkkel.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **Firmware**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn firmware API nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Fyrverkeri AI
|
||
|
||
1. Gå over til [Fireworks AI-konsollen](https://app.fireworks.ai/), opprett en konto og klikk på **Create API Key**.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **Fireworks AI**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn Fireworks AI API nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell som _Kimi K2 Instruct_.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### GitLab Duo
|
||
|
||
GitLab Duo gir AI-drevet agentchat med native verktøyoppringingsfunksjoner gjennom GitLabs antropiske proxy.
|
||
|
||
1. Kjør kommandoen `/connect` og velg GitLab.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
2. Velg autentiseringsmetoden din:
|
||
|
||
```txt
|
||
┌ Select auth method
|
||
│
|
||
│ OAuth (Recommended)
|
||
│ Personal Access Token
|
||
└
|
||
```
|
||
|
||
#### Bruke OAuth (anbefalt)
|
||
|
||
Velg **OAuth** og nettleseren din åpnes for autorisasjon.
|
||
|
||
#### Bruker personlig tilgangstoken
|
||
1. Gå til [GitLab User Settings > Access Tokens](https://gitlab.com/-/user_settings/personal_access_tokens)
|
||
2. Klikk på **Legg til nytt token**
|
||
3. Navn: `OpenCode`, omfang: `api`
|
||
4. Kopier tokenet (starter med `glpat-`)
|
||
5. Skriv den inn i terminalen
|
||
|
||
3. Kjør kommandoen `/models` for å se tilgjengelige modeller.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
Tre Claude-baserte modeller er tilgjengelige:
|
||
- **duo-chat-haiku-4-5** (standard) - Raske svar for raske oppgaver
|
||
- **duo-chat-sonnet-4-5** - Balansert ytelse for de fleste arbeidsflyter
|
||
- **duo-chat-opus-4-5** - Mest egnet for kompleks analyse
|
||
|
||
:::note
|
||
Du kan også spesifisere 'GITLAB_TOKEN' miljøvariabel hvis du ikke vil
|
||
for å lagre token i opencode auth-lagring.
|
||
:::
|
||
|
||
##### Selvhostet GitLab
|
||
|
||
:::note[compliance note]
|
||
OpenCode bruker en liten modell for noen AI oppgaver som å generere økttittelen.
|
||
Den er konfigurert til å bruke gpt-5-nano som standard, hostet av Zen. For å låse OpenCode
|
||
for kun å bruke din egen GitLab-hostede forekomst, legg til følgende i din
|
||
`opencode.json` fil. Det anbefales også å deaktivere øktdeling.
|
||
|
||
```json
|
||
{
|
||
"$schema": "https://opencode.ai/config.json",
|
||
"small_model": "gitlab/duo-chat-haiku-4-5",
|
||
"share": "disabled"
|
||
}
|
||
```
|
||
|
||
:::
|
||
|
||
For selvhostede GitLab-forekomster:
|
||
|
||
```bash
|
||
export GITLAB_INSTANCE_URL=https://gitlab.company.com
|
||
export GITLAB_TOKEN=glpat-...
|
||
```
|
||
|
||
Hvis forekomsten din kjører en tilpasset AI-gateway:
|
||
|
||
```bash
|
||
GITLAB_AI_GATEWAY_URL=https://ai-gateway.company.com
|
||
```
|
||
|
||
Eller legg til bash-profilen din:
|
||
|
||
```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
|
||
GitLab-administratoren din må aktivere følgende:
|
||
|
||
1. [Duo Agent Platform](https://docs.gitlab.com/user/gitlab_duo/turn_on_off/) for brukeren, gruppen eller forekomsten
|
||
2. Funksjonsflagg (via Rails-konsollen):
|
||
- `agent_platform_claude_code`
|
||
- `third_party_agents_enabled`
|
||
:::
|
||
|
||
##### OAuth for selvvertsbaserte forekomster
|
||
|
||
For å få Oauth til å fungere for din selvhostede forekomst, må du opprette
|
||
en ny applikasjon (Innstillinger → Programmer) med
|
||
tilbakeringing URL `http://127.0.0.1:8080/callback` og følgende omfang:
|
||
|
||
- api (Få tilgang til API på dine vegne)
|
||
- read_user (Les din personlige informasjon)
|
||
- read_repository (tillater skrivebeskyttet tilgang til depotet)
|
||
|
||
Utsett deretter applikasjonen ID som miljøvariabel:
|
||
|
||
```bash
|
||
export GITLAB_OAUTH_CLIENT_ID=your_application_id_here
|
||
```
|
||
|
||
Mer dokumentasjon på [opencode-gitlab-auth](https://www.npmjs.com/package/@gitlab/opencode-gitlab-auth) hjemmeside.
|
||
|
||
##### Konfigurasjon
|
||
|
||
Tilpass gjennom `opencode.json`:
|
||
|
||
```json title="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 Verktøy (valgfritt, men sterkt anbefalt)
|
||
|
||
For å få tilgang til GitLab-verktøy (sammenslåingsforespørsler, problemer, pipelines, CI/CD, etc.):
|
||
|
||
```json title="opencode.json"
|
||
{
|
||
"$schema": "https://opencode.ai/config.json",
|
||
"plugin": ["@gitlab/opencode-gitlab-plugin"]
|
||
}
|
||
```
|
||
|
||
Denne plugin-en gir omfattende GitLab-repository-administrasjonsfunksjoner, inkludert MR-anmeldelser, problemsporing, pipeline-overvåking og mer.
|
||
|
||
---
|
||
|
||
### GitHub Copilot
|
||
|
||
Slik bruker du GitHub Copilot-abonnementet med OpenCode:
|
||
|
||
:::note
|
||
Noen modeller kan trenge en [Pro+
|
||
abonnement](https://github.com/features/copilot/plans) å bruke.
|
||
|
||
Noen modeller må aktiveres manuelt i [GitHub Copilot-innstillingene](https://docs.github.com/en/copilot/how-tos/use-ai-models/configure-access-to-ai-models#setup-for-individual-use).
|
||
:::
|
||
|
||
1. Kjør kommandoen `/connect` og søk etter GitHub Copilot.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
2. Naviger til [github.com/login/device](https://github.com/login/device) og skriv inn koden.
|
||
|
||
```txt
|
||
┌ Login with GitHub Copilot
|
||
│
|
||
│ https://github.com/login/device
|
||
│
|
||
│ Enter code: 8F43-6FCF
|
||
│
|
||
└ Waiting for authorization...
|
||
```
|
||
|
||
3. Kjør nå kommandoen `/models` for å velge modellen du ønsker.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Google Vertex AI
|
||
|
||
Slik bruker du Google Vertex AI med OpenCode:
|
||
|
||
1. Gå over til **Model Garden** i Google Cloud Console og sjekk
|
||
modeller tilgjengelig i din region.
|
||
|
||
:::note
|
||
Du må ha et Google Cloud-prosjekt med Vertex AI API aktivert.
|
||
:::
|
||
|
||
2. Angi de nødvendige miljøvariablene:
|
||
- `GOOGLE_CLOUD_PROJECT`: Google Cloud-prosjektet ditt ID
|
||
- `VERTEX_LOCATION` (valgfritt): Regionen for verteks AI (standard til `global`)
|
||
- Autentisering (velg en):
|
||
- `GOOGLE_APPLICATION_CREDENTIALS`: Bane til tjenestekontoen JSON nøkkelfil
|
||
- Autentiser med gcloud CLI: `gcloud auth application-default login`
|
||
|
||
Sett dem mens du kjører opencode.
|
||
|
||
```bash
|
||
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id opencode
|
||
```
|
||
|
||
Eller legg dem til på bash-profilen din.
|
||
|
||
```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 tilgjengeligheten og reduserer feil uten ekstra kostnad. Bruk regionale endepunkter (f.eks. `us-central1`) for krav til dataopphold. [Finn ut mer](https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/use-partner-models#regional_and_global_endpoints)
|
||
:::
|
||
|
||
3. Kjør kommandoen `/models` for å velge modellen du ønsker.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Groq
|
||
|
||
1. Gå over til [Groq-konsollen](https://console.groq.com/), klikk på **Create API Key**, og kopier nøkkelen.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter Groq.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn API-nøkkelen for leverandøren.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge den du ønsker.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Klemmer ansikt
|
||
|
||
[Hugging Face Inference Providers](https://huggingface.co/docs/inference-providers) gir tilgang til åpne modeller som støttes av 17+ leverandører.
|
||
|
||
1. Gå over til [Hugging Face-innstillinger](https://huggingface.co/settings/tokens/new?ownUserPermissions=inference.serverless.write&tokenType=fineGrained) for å opprette et token med tillatelse til å ringe til inferensleverandører.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **Hugging Face**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn ditt Hugging Face-token.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell som _Kimi-K2-Instruct_ eller _GLM-4.6_.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Helikon
|
||
|
||
[Helicone](https://helicone.ai) er en LLM observerbarhetsplattform som gir logging, overvåking og analyser for AI-applikasjonene dine. Helicone AI Gateway ruter forespørslene dine til riktig leverandør automatisk basert på modellen.
|
||
|
||
1. Gå over til [Helicone](https://helicone.ai), opprett en konto og generer en API nøkkel fra dashbordet.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **Helicone**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn Helicone API-nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
For flere leverandører og avanserte funksjoner som bufring og hastighetsbegrensning, sjekk [Helicone-dokumentasjonen](https://docs.helicone.ai).
|
||
|
||
#### Valgfrie konfigurasjoner
|
||
|
||
I tilfelle du ser en funksjon eller modell fra Helicone som ikke konfigureres automatisk gjennom opencode, kan du alltid konfigurere den selv.
|
||
|
||
Her er [Helicone's Model Directory](https://helicone.ai/models), du trenger denne for å hente ID-ene til modellene du vil legge til.
|
||
|
||
```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",
|
||
},
|
||
},
|
||
},
|
||
},
|
||
}
|
||
```
|
||
|
||
#### Egendefinerte topptekster
|
||
|
||
Helicone støtter tilpassede overskrifter for funksjoner som bufring, brukersporing og øktadministrasjon. Legg dem til leverandørkonfigurasjonen din ved å bruke `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",
|
||
},
|
||
},
|
||
},
|
||
},
|
||
}
|
||
```
|
||
|
||
##### Sesjonssporing
|
||
|
||
Helicones [Sessions](https://docs.helicone.ai/features/sessions) funksjon lar deg gruppere relaterte LLM forespørsler sammen. Bruk [opencode-helicone-session](https://github.com/H2Shami/opencode-helicone-session) plugin for automatisk å logge hver OpenCode-samtale som en økt i Helicone.
|
||
|
||
```bash
|
||
npm install -g opencode-helicone-session
|
||
```
|
||
|
||
Legg den til i konfigurasjonen din.
|
||
|
||
```json title="opencode.json"
|
||
{
|
||
"plugin": ["opencode-helicone-session"]
|
||
}
|
||
```
|
||
|
||
Programtillegget injiserer `Helicone-Session-Id` og `Helicone-Session-Name` overskrifter i forespørslene dine. På Helicones Sessions-side vil du se hver OpenCode-samtale oppført som en separat økt.
|
||
|
||
##### Vanlige helikonhoder
|
||
|
||
| Overskrift | Beskrivelse |
|
||
| -------------------------- | -------------------------------------------------------------------------- |
|
||
| `Helicone-Cache-Enabled` | Aktiver responsbufring (`true`/`false`) |
|
||
| `Helicone-User-Id` | Spor beregninger etter bruker |
|
||
| `Helicone-Property-[Name]` | Legg til egendefinerte egenskaper (f.eks. `Helicone-Property-Environment`) |
|
||
| `Helicone-Prompt-Id` | Knytt forespørsler til spørsmålsversjoner |
|
||
|
||
Se [Helicone Header Directory](https://docs.helicone.ai/helicone-headers/header-directory) for alle tilgjengelige overskrifter.
|
||
|
||
---
|
||
|
||
### lama.cpp
|
||
|
||
Du kan konfigurere opencode for å bruke lokale modeller gjennom [llama.cpps](https://github.com/ggml-org/llama.cpp) lama-server-verktøy
|
||
|
||
```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 eksemplet:
|
||
|
||
- `llama.cpp` er den tilpassede leverandøren ID. Dette kan være hvilken som helst streng du vil.
|
||
- `npm` spesifiserer pakken som skal brukes for denne leverandøren. Her brukes `@ai-sdk/openai-compatible` for enhver OpenAI-kompatibel API.
|
||
- `name` er visningsnavnet for leverandøren i UI.
|
||
- `options.baseURL` er endepunktet for den lokale serveren.
|
||
- `models` er et kart over modell-ID-er til deres konfigurasjoner. Modellnavnet vil vises i modellvalglisten.
|
||
|
||
---
|
||
|
||
### IO.NET
|
||
|
||
IO.NET tilbyr 17 modeller optimert for ulike brukstilfeller:
|
||
|
||
1. Gå over til [IO.NET-konsollen](https://ai.io.net/), opprett en konto og generer en API-nøkkel.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **IO.NET**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn nøkkelen IO.NET API.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### LM Studio
|
||
|
||
Du kan konfigurere opencode for å bruke lokale modeller gjennom 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 eksemplet:
|
||
|
||
- `lmstudio` er den tilpassede leverandøren ID. Dette kan være hvilken som helst streng du vil.
|
||
- `npm` spesifiserer pakken som skal brukes for denne leverandøren. Her brukes `@ai-sdk/openai-compatible` for enhver OpenAI-kompatibel API.
|
||
- `name` er visningsnavnet for leverandøren i UI.
|
||
- `options.baseURL` er endepunktet for den lokale serveren.
|
||
- `models` er et kart over modell-ID-er til deres konfigurasjoner. Modellnavnet vil vises i modellvalglisten.
|
||
|
||
---
|
||
|
||
### Måneskudd AI
|
||
|
||
Slik bruker du Kimi K2 fra Moonshot AI:
|
||
|
||
1. Gå over til [Moonshot AI-konsollen](https://platform.moonshot.ai/console), opprett en konto og klikk på **Opprett API-nøkkel**.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **Moonshot AI**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn Moonshot API-nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge _Kimi K2_.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### MiniMax
|
||
|
||
1. Gå over til [MiniMax API-konsollen](https://platform.minimax.io/login), opprett en konto og generer en API-nøkkel.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **MiniMax**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn MiniMax API-nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell som _M2.1_.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Nebius Token Factory
|
||
|
||
1. Gå over til [Nebius Token Factory-konsollen](https://tokenfactory.nebius.com/), opprett en konto og klikk på **Legg til nøkkel**.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **Nebius Token Factory**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn Nebius Token Factory API-nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell som _Kimi K2 Instruct_.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Ollama
|
||
|
||
Du kan konfigurere opencode for å bruke lokale modeller gjennom Ollama.
|
||
|
||
:::tip
|
||
Ollama kan automatisk konfigurere seg selv for OpenCode. Se [Ollama-integrasjonsdokumentene](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 eksemplet:
|
||
|
||
- `ollama` er den tilpassede leverandøren ID. Dette kan være hvilken som helst streng du vil.
|
||
- `npm` spesifiserer pakken som skal brukes for denne leverandøren. Her brukes `@ai-sdk/openai-compatible` for enhver OpenAI-kompatibel API.
|
||
- `name` er visningsnavnet for leverandøren i UI.
|
||
- `options.baseURL` er endepunktet for den lokale serveren.
|
||
- `models` er et kart over modell-ID-er til deres konfigurasjoner. Modellnavnet vil vises i modellvalglisten.
|
||
|
||
:::tip
|
||
Hvis verktøykall ikke fungerer, prøv å øke `num_ctx` i Ollama. Start rundt 16k - 32k.
|
||
:::
|
||
|
||
---
|
||
|
||
### Ollama Cloud
|
||
|
||
Slik bruker du Ollama Cloud med OpenCode:
|
||
|
||
1. Gå over til [https://ollama.com/](https://ollama.com/) og logg på eller opprett en konto.
|
||
|
||
2. Naviger til **Innstillinger** > **Nøkler** og klikk på **Legg til API nøkkel** for å generere en ny API nøkkel.
|
||
|
||
3. Kopier API-nøkkelen for bruk i OpenCode.
|
||
|
||
4. Kjør kommandoen `/connect` og søk etter **Ollama Cloud**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
5. Skriv inn din Ollama Cloud API nøkkel.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
6. **Viktig**: Før du bruker skymodeller i OpenCode, må du hente modellinformasjonen lokalt:
|
||
|
||
```bash
|
||
ollama pull gpt-oss:20b-cloud
|
||
```
|
||
|
||
7. Kjør kommandoen `/models` for å velge din Ollama Cloud-modell.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### OpenAI
|
||
|
||
Vi anbefaler at du registrerer deg for [ChatGPT Plus eller Pro](https://chatgpt.com/pricing).
|
||
|
||
1. Når du har registrert deg, kjør kommandoen `/connect` og velg OpenAI.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
2. Her kan du velge alternativet **ChatGPT Plus/Pro** og det åpner nettleseren din
|
||
og ber deg om å autentisere.
|
||
|
||
```txt
|
||
┌ Select auth method
|
||
│
|
||
│ ChatGPT Plus/Pro
|
||
│ Manually enter API Key
|
||
└
|
||
```
|
||
|
||
3. Nå skal alle OpenAI-modellene være tilgjengelige når du bruker kommandoen `/models`.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
##### Bruke API-tastene
|
||
|
||
Hvis du allerede har en API-nøkkel, kan du velge **Angi API-nøkkel manuelt** og lime den inn i terminalen.
|
||
|
||
---
|
||
|
||
### OpenCode Zen
|
||
|
||
OpenCode Zen er en liste over testede og verifiserte modeller levert av OpenCode-teamet. [Finn ut mer](/docs/zen).
|
||
|
||
1. Logg på **<a href={console}>OpenCode Zen</a>** og klikk på **Create API Key**.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **OpenCode Zen**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn OpenCode API-nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell som _Qwen 3 Coder 480B_.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### OpenRouter
|
||
|
||
1. Gå over til [OpenRouter-dashbordet](https://openrouter.ai/settings/keys), klikk på **Create API Key**, og kopier nøkkelen.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter OpenRouter.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn API-nøkkelen for leverandøren.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Mange OpenRouter-modeller er forhåndslastet som standard, kjør kommandoen `/models` for å velge den du ønsker.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
Du kan også legge til flere modeller gjennom opencode-konfigurasjonen.
|
||
|
||
```json title="opencode.json" {6}
|
||
{
|
||
"$schema": "https://opencode.ai/config.json",
|
||
"provider": {
|
||
"openrouter": {
|
||
"models": {
|
||
"somecoolnewmodel": {}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
5. Du kan også tilpasse dem gjennom opencode-konfigurasjonen. Her er et eksempel på å spesifisere en leverandør
|
||
|
||
```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 Kjerne
|
||
|
||
SAP AI Core gir tilgang til 40+ modeller fra OpenAI, Anthropic, Google, Amazon, Meta, Mistral og AI21 gjennom en enhetlig plattform.
|
||
|
||
1. Gå til din [SAP BTP Cockpit](https://account.hana.ondemand.com/), naviger til din SAP AI kjernetjenesteforekomst, og lag en tjenestenøkkel.
|
||
|
||
:::tip
|
||
Tjenestenøkkelen er et JSON-objekt som inneholder `clientid`, `clientsecret`, `url` og `serviceurls.AI_API_URL`. Du finner AI kjerneforekomsten din under **Tjenester** > **Forekomster og abonnementer** i BTP cockpiten.
|
||
:::
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **SAP AI Core**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn tjenestenøkkelen JSON.
|
||
|
||
```txt
|
||
┌ Service key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
Eller angi miljøvariabelen `AICORE_SERVICE_KEY`:
|
||
|
||
```bash
|
||
AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}' opencode
|
||
```
|
||
|
||
Eller legg den til bash-profilen din:
|
||
|
||
```bash title="~/.bash_profile"
|
||
export AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}'
|
||
```
|
||
|
||
4. Angi eventuelt distribusjon ID og ressursgruppe:
|
||
|
||
```bash
|
||
AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode
|
||
```
|
||
|
||
:::note
|
||
Disse innstillingene er valgfrie og bør konfigureres i henhold til SAP AI kjerneoppsettet.
|
||
:::
|
||
|
||
5. Kjør kommandoen `/models` for å velge fra 40+ tilgjengelige modeller.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### OVHcloud AI endepunkter
|
||
|
||
1. Gå over 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å **Opprett en ny API-nøkkel**.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **OVHcloud AI endepunkter**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn OVHcloud AI Endpoints API nøkkel.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell som _gpt-oss-120b_.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Scaleway
|
||
|
||
Slik bruker du [Scaleway Generative APIs](https://www.scaleway.com/en/docs/generative-apis/) med OpenCode:
|
||
|
||
1. Gå over til [Scaleway Console IAM innstillinger](https://console.scaleway.com/iam/api-keys) for å generere en ny API nøkkel.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **Scaleway**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn Scaleway API-nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell som _devstral-2-123b-instruct-2512_ eller _gpt-oss-120b_.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Sammen AI
|
||
|
||
1. Gå over til [Together AI-konsollen](https://api.together.ai), opprett en konto og klikk på **Legg til nøkkel**.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **Together AI**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn Together AI API nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell som _Kimi K2 Instruct_.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Venezia AI
|
||
|
||
1. Gå over til [Venezia AI-konsollen](https://venice.ai), opprett en konto og generer en API-nøkkel.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **Venezia AI**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn Venezia AI API nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell som _Llama 3.3 70B_.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Vercel AI Gateway
|
||
|
||
Vercel AI Gateway lar deg få tilgang til modeller fra OpenAI, Anthropic, Google, xAI og mer gjennom et enhetlig endepunkt. Modeller tilbys til listepris uten påslag.
|
||
|
||
1. Gå over til [Vercel dashboard](https://vercel.com/), naviger til fanen **AI Gateway**, og klikk på **API nøkler** for å opprette en ny API nøkkel.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **Vercel AI Gateway**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn Vercel AI Gateway API nøkkel.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
Du kan også tilpasse modeller gjennom opencode-konfigurasjonen. Her er et eksempel på spesifisering av leverandørrutingsrekkefølge.
|
||
|
||
```json title="opencode.json"
|
||
{
|
||
"$schema": "https://opencode.ai/config.json",
|
||
"provider": {
|
||
"vercel": {
|
||
"models": {
|
||
"anthropic/claude-sonnet-4": {
|
||
"options": {
|
||
"order": ["anthropic", "vertex"]
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
Noen nyttige rutealternativer:
|
||
|
||
| Alternativ | Beskrivelse |
|
||
| ------------------- | ------------------------------------------------------------- |
|
||
| `order` | Providersekvens for å prøve |
|
||
| `only` | Begrens til spesifikke leverandører |
|
||
| `zeroDataRetention` | Bruk kun leverandører med null retningslinjer for datalagring |
|
||
|
||
---
|
||
|
||
### xAI
|
||
|
||
1. Gå over til [xAI-konsollen](https://console.x.ai/), opprett en konto og generer en API-nøkkel.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **xAI**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn xAI API-nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell som _Grok Beta_.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### Z.AI
|
||
|
||
1. Gå over til [Z.AI API-konsollen](https://z.ai/manage-apikey/apikey-list), opprett en konto og klikk på **Opprett en ny API-nøkkel**.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter **Z.AI**.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
Hvis du abonnerer på **GLM Coding Plan**, velg **Z.AI Coding Plan**.
|
||
|
||
3. Skriv inn Z.AI API-nøkkelen.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Kjør kommandoen `/models` for å velge en modell som _GLM-4.7_.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
---
|
||
|
||
### ZenMux
|
||
|
||
1. Gå over til [ZenMux-dashbordet](https://zenmux.ai/settings/keys), klikk på **Create API Key**, og kopier nøkkelen.
|
||
|
||
2. Kjør kommandoen `/connect` og søk etter ZenMux.
|
||
|
||
```txt
|
||
/connect
|
||
```
|
||
|
||
3. Skriv inn API-nøkkelen for leverandøren.
|
||
|
||
```txt
|
||
┌ API key
|
||
│
|
||
│
|
||
└ enter
|
||
```
|
||
|
||
4. Mange ZenMux-modeller er forhåndslastet som standard, kjør kommandoen `/models` for å velge den du ønsker.
|
||
|
||
```txt
|
||
/models
|
||
```
|
||
|
||
Du kan også legge til flere modeller gjennom opencode-konfigurasjonen.
|
||
|
||
```json title="opencode.json" {6}
|
||
{
|
||
"$schema": "https://opencode.ai/config.json",
|
||
"provider": {
|
||
"zenmux": {
|
||
"models": {
|
||
"somecoolnewmodel": {}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## Egendefinert leverandør
|
||
|
||
Slik legger du til en **OpenAI-kompatibel**-leverandør som ikke er oppført i `/connect`-kommandoen:
|
||
|
||
:::tip
|
||
Du kan bruke hvilken som helst OpenAI-kompatibel leverandør med opencode. De fleste moderne AI-leverandører tilbyr OpenAI-kompatible APIer.
|
||
:::
|
||
|
||
1. Kjør kommandoen `/connect` og rull ned til **Annet**.
|
||
|
||
```bash
|
||
$ /connect
|
||
|
||
┌ Add credential
|
||
│
|
||
◆ Select provider
|
||
│ ...
|
||
│ ● Other
|
||
└
|
||
```
|
||
|
||
2. Skriv inn en unik ID for leverandøren.
|
||
|
||
```bash
|
||
$ /connect
|
||
|
||
┌ Add credential
|
||
│
|
||
◇ Enter provider id
|
||
│ myprovider
|
||
└
|
||
```
|
||
|
||
:::note
|
||
Velg en minneverdig ID, du vil bruke denne i konfigurasjonsfilen din.
|
||
:::
|
||
|
||
3. Skriv inn API-nøkkelen for leverandøren.
|
||
|
||
```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. Opprett eller oppdater `opencode.json`-filen i prosjektkatalogen:
|
||
|
||
```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 konfigurasjonsalternativene:
|
||
- **npm**: AI SDK pakke å bruke, `@ai-sdk/openai-compatible` for OpenAI-kompatible leverandører
|
||
- **navn**: Visningsnavn i UI.
|
||
- **modeller**: Tilgjengelige modeller.
|
||
- **options.baseURL**: API endepunkt URL.
|
||
- **options.apiKey**: Angi API-nøkkelen hvis du ikke bruker auth.
|
||
- **options.headers**: Angi egendefinerte overskrifter.
|
||
|
||
Mer om de avanserte alternativene i eksemplet nedenfor.
|
||
|
||
5. Kjør kommandoen `/models` og din egendefinerte leverandør og modeller vil vises i utvalgslisten.
|
||
|
||
---
|
||
|
||
##### Eksempel
|
||
|
||
Her er et eksempel på innstilling av alternativene `apiKey`, `headers` og modell `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
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
Konfigurasjonsdetaljer:
|
||
|
||
- **apiKey**: Angi med `env` variabel syntaks, [finn ut mer](/docs/config#env-vars).
|
||
- **overskrifter**: Egendefinerte overskrifter sendt med hver forespørsel.
|
||
- **limit.context**: Maksimalt inndatatoken som modellen godtar.
|
||
- **limit.output**: Maksimalt antall tokens modellen kan generere.
|
||
|
||
`limit`-feltene lar OpenCode forstå hvor mye kontekst du har igjen. Standardleverandører henter disse automatisk fra models.dev.
|
||
|
||
---
|
||
|
||
## Feilsøking
|
||
|
||
Hvis du har problemer med å konfigurere en leverandør, sjekk følgende:
|
||
|
||
1. **Sjekk autentiseringsoppsettet**: Kjør `opencode auth list` for å se om legitimasjonen
|
||
for leverandøren legges til konfigurasjonen din.
|
||
|
||
Dette gjelder ikke leverandører som Amazon Bedrock, som er avhengige av miljøvariabler for godkjenning.
|
||
|
||
2. For tilpassede leverandører, sjekk opencode-konfigurasjonen og:
|
||
- Sørg for at leverandøren ID som brukes i `/connect`-kommandoen samsvarer med ID i opencode-konfigurasjonen.
|
||
– Den riktige npm-pakken brukes for leverandøren. Bruk for eksempel `@ai-sdk/cerebras` for Cerebras. Og for alle andre OpenAI-kompatible leverandører, bruk `@ai-sdk/openai-compatible`.
|
||
- Kontroller at riktig API-endepunkt er brukt i `options.baseURL`-feltet.
|