---
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økkelen 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`.

---

### Konfigurasjon

Du kan tilpasse leverandørene gjennom `provider`-delen i OpenCode
konfig.

---

#### Base-URL

Du kan tilpasse base-URL-en 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 Zen` og gå til [opencode.ai/auth](https://opencode.ai/zen).

   ```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.

---

## OpenCode Go

OpenCode Go er en lavpris abonnementsplan som gir pålitelig tilgang til populære åpne kodemodeller levert av OpenCode-teamet som har vært
testet og verifisert for å fungere godt med OpenCode.

1. Kjør kommandoen `/connect` i TUI, velg `OpenCode Go`, og gå til [opencode.ai/auth](https://opencode.ai/zen).

   ```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
   ```

---

### Amazon Bedrock

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-endepunkter

   Hvis du bruker VPC-endepunkter 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
   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"
        }
      }
    }
  }
}
```

:::

---

### Anthropic

1. Når du har registrert deg, kjør kommandoen `/connect` og velg Anthropic.

   ```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 Anthropic-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-nøkler

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.

---

### Atomic Chat

Du kan konfigurere opencode til å bruke lokale modeller via [Atomic Chat](https://atomic.chat) — et skrivebordsprogram som kjører lokale LLM-er bak en OpenAI-kompatibel API-server (standard endepunkt `http://127.0.0.1:1337/v1`).

```json title="opencode.json" "atomic-chat" {5, 6, 8, 10-14}
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "atomic-chat": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Atomic Chat (local)",
      "options": {
        "baseURL": "http://127.0.0.1:1337/v1"
      },
      "models": {
        "<your-model-id>": {
          "name": "<your-model-name>"
        }
      }
    }
  }
}
```

I dette eksempelet:

- `atomic-chat` er den egendefinerte leverandør-ID-en. Det kan være en hvilken som helst streng.
- `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 grensesnittet.
- `options.baseURL` er endepunktet for den lokale serveren. Endre vert og port for å matche Atomic Chat-oppsettet ditt.
- `models` er en kartlegging av modell-IDer til visningsnavnene deres. Hver ID må samsvare med `id` som returneres av `GET /v1/models` — kjør `curl http://127.0.0.1:1337/v1/models` for å liste ID-ene som er lastet inn i Atomic Chat nå.

:::tip
Hvis verktøykall ikke fungerer godt, velg en lastet modell med god tool calling-støtte (for eksempel en Qwen-Coder- eller DeepSeek-Coder-variant).
:::

---

### 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 V4 Pro_.

   ```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
   ```

---

### Firmware

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
   ```

---

### Fireworks 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 Anthropic-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[Merknad om samsvar]
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/duo_agent_platform/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/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"
      }
    }
  }
}
```

##### 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": ["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
   ```

---

### Hugging Face

[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
   ```

---

### Helicone

[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 headere

Helicone støtter tilpassede headere 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` headere i forespørslene dine. På Helicones Sessions-side vil du se hver OpenCode-samtale oppført som en separat økt.

##### Vanlige Helicone-headere

| 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.

---

### llama.cpp

Du kan konfigurere OpenCode for å bruke lokale modeller gjennom [llama.cpp](https://github.com/ggml-org/llama.cpp) llama-server-verktøyet.

```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.

---

### Moonshot 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-nøkler

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 Core

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 Cockpit.
   :::

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 Endpoints

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 Endpoints**.

   ```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
   ```

---

### Together 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
   ```

---

### Venice AI

1. Gå over til [Venice AI-konsollen](https://venice.ai), opprett en konto og generer en API-nøkkel.

2. Kjør kommandoen `/connect` og søk etter **Venice AI**.

   ```txt
   /connect
   ```

3. Skriv inn Venice 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).
- **headere**: Egendefinerte headere sendt med hver forespørsel.
- **limit.context**: Maksimalt Input Tokens 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ør-ID-en 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.
