Leverandører

Bruke en hvilken som helst LLM-leverandør i OpenCode.

OpenCode bruker AI SDK og 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:

Legg til API-nøklene for leverandøren ved å bruke kommandoen /connect.
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.

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

Kjør kommandoen /connect i TUI, velg opencode og gå til opencode.ai/auth.
```
/connect
```
Logg på, legg til faktureringsdetaljene dine og kopier API-nøkkelen.
Lim inn API-nøkkelen.
```
┌ API key
│
│
└ enter
```
Kjør /models i TUI for å se listen over modeller vi anbefaler.
```
/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.

302.AI

Gå over til 302.AI-konsollen, opprett en konto og generer en API-nøkkel.
Kjør kommandoen /connect og søk etter 302.AI.
```
/connect
```
Skriv inn 302.AI API-nøkkelen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell.
```
/models
```

Amazon Bedrock

Slik bruker du Amazon Bedrock med OpenCode:

Gå over til modellkatalogen i Amazon Bedrock-konsollen og be om tilgang til modellene du ønsker.

Du må ha tilgang til modellen du ønsker i Amazon Bedrock.
Konfigurer autentisering ved å bruke en av følgende metoder:

Miljøvariabler (hurtigstart)

Angi en av disse miljøvariablene mens du kjører OpenCode:
Terminal window
```
# 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_profile
```
export AWS_PROFILE=my-dev-profile
export AWS_REGION=us-east-1
```
Konfigurasjonsfil (anbefalt)

For prosjektspesifikk eller vedvarende konfigurasjon, bruk opencode.json:
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)
Alternativer for konfigurasjonsfil har forrang over miljøvariabler.

Avansert: VPC Sluttpunkter

Hvis du bruker VPC-endepunkter for Bedrock:
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"
      }
    }
  }
}
```
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
Når et bærertoken er angitt (via /connect eller AWS_BEARER_TOKEN_BEDROCK), har det forrang over alle AWS legitimasjonsmetoder inkludert konfigurerte profiler.
Kjør kommandoen /models for å velge modellen du ønsker.
```
/models
```

For egendefinerte slutningsprofiler, bruk modellen og leverandørnavnet i nøkkelen og sett egenskapen id til arn. Dette sikrer korrekt caching:

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

Når du har registrert deg, kjør kommandoen /connect og velg Anthropic.
```
/connect
```
Her kan du velge alternativet Claude Pro/Max og det vil åpne nettleseren din og ber deg om å autentisere.
```
┌ Select auth method
│
│ Claude Pro/Max
│ Create an API Key
│ Manually enter API Key
└
```
Nå skal alle Anthropic-modellene være tilgjengelige når du bruker kommandoen /models.
```
/models
```

Å bruke Claude Pro/Max-abonnementet ditt i opencode støttes ikke offisielt av Anthropic.

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

Gå over til Azure-portalen 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
Gå til Azure AI Foundry og distribuer en modell.

Distribusjonsnavnet må samsvare med modellnavnet for at OpenCode skal fungere skikkelig.
Kjør kommandoen /connect og søk etter Azure.
```
/connect
```
Skriv inn API-nøkkelen.
```
┌ API key
│
│
└ enter
```
Angi ressursnavnet ditt som en miljøvariabel:
Terminal window
```
AZURE_RESOURCE_NAME=XXX opencode
```
Eller legg den til bash-profilen din:
~/.bash_profile
```
export AZURE_RESOURCE_NAME=XXX
```
Kjør kommandoen /models for å velge den distribuerte modellen.
```
/models
```

Azure Cognitive Services

Gå over til Azure-portalen 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
Gå til Azure AI Foundry og distribuer en modell.

Distribusjonsnavnet må samsvare med modellnavnet for at OpenCode skal fungere skikkelig.
Kjør kommandoen /connect og søk etter Azure Cognitive Services.
```
/connect
```
Skriv inn API-nøkkelen.
```
┌ API key
│
│
└ enter
```
Angi ressursnavnet ditt som en miljøvariabel:
Terminal window
```
AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
```
Eller legg den til bash-profilen din:
~/.bash_profile
```
export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX
```
Kjør kommandoen /models for å velge den distribuerte modellen.
```
/models
```

Baseten

Gå over til Baseten, opprett en konto og generer en API nøkkel.
Kjør kommandoen /connect og søk etter Baseten.
```
/connect
```
Skriv inn din Baseten API nøkkel.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell.
```
/models
```

Cerebras

Gå over til Cerebras-konsollen, opprett en konto og generer en API-nøkkel.
Kjør kommandoen /connect og søk etter Cerebras.
```
/connect
```
Skriv inn Cerebras API-nøkkelen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell som Qwen 3 Coder 480B.
```
/models
```

Cloudflare AI Gateway lar deg få tilgang til modeller fra OpenAI, Anthropic, Workers AI og mer gjennom et enhetlig endepunkt. Med Unified Billing trenger du ikke separate API-nøkler for hver leverandør.

Gå over til Cloudflare-dashbordet, naviger til AI > AI Gateway, og lag en ny gateway.

Angi konto ID og gateway ID som miljøvariabler.

export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
export CLOUDFLARE_GATEWAY_ID=your-gateway-id

Kjør kommandoen /connect og søk etter Cloudflare AI Gateway.
```
/connect
```
Skriv inn Cloudflare API-tokenet ditt.
```
┌ API key
│
│
└ enter
```
Eller angi den som en miljøvariabel.
~/.bash_profile
```
export CLOUDFLARE_API_TOKEN=your-api-token
```

Kjør kommandoen /models for å velge en modell.

/models

Du kan også legge til modeller gjennom OpenCode-konfigurasjonen.

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "cloudflare-ai-gateway": {
      "models": {
        "openai/gpt-4o": {},
        "anthropic/claude-sonnet-4": {}
      }
    }
  }
}

Cortecs

Gå over til Cortecs-konsollen, opprett en konto og generer en API-nøkkel.
Kjør kommandoen /connect og søk etter Cortecs.
```
/connect
```
Skriv inn Cortecs API-nøkkelen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell som Kimi K2 Instruct.
```
/models
```

DeepSeek

Gå over til DeepSeek-konsollen, opprett en konto og klikk på Opprett ny API-nøkkel.
Kjør kommandoen /connect og søk etter DeepSeek.
```
/connect
```
Skriv inn DeepSeek API-nøkkelen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en DeepSeek-modell som DeepSeek Reasoner.
```
/models
```

Deep Infra

Gå over til Deep Infra-dashbordet, opprett en konto og generer en API-nøkkel.
Kjør kommandoen /connect og søk etter Deep Infra.
```
/connect
```
Skriv inn Deep Infra API nøkkelen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell.
```
/models
```

Firmware

Gå over til Firmware dashboard, opprett en konto og generer en API nøkkel.
Kjør kommandoen /connect og søk etter Firmware.
```
/connect
```
Skriv inn firmware API nøkkelen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell.
```
/models
```

Fireworks AI

Gå over til Fireworks AI-konsollen, opprett en konto og klikk på Create API Key.
Kjør kommandoen /connect og søk etter Fireworks AI.
```
/connect
```
Skriv inn Fireworks AI API nøkkelen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell som Kimi K2 Instruct.
```
/models
```

GitLab Duo

GitLab Duo gir AI-drevet agentchat med native verktøyoppringingsfunksjoner gjennom GitLabs Anthropic-proxy.

Kjør kommandoen /connect og velg GitLab.
```
/connect
```
Velg autentiseringsmetoden din:
```
┌ 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
2. Klikk på Legg til nytt token
3. Navn: OpenCode, omfang: api
4. Kopier tokenet (starter med glpat-)
5. Skriv den inn i terminalen
Kjør kommandoen /models for å se tilgjengelige modeller.
```
/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

Selvhostet GitLab

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.

{
  "$schema": "https://opencode.ai/config.json",
  "small_model": "gitlab/duo-chat-haiku-4-5",
  "share": "disabled"
}

For selvhostede GitLab-forekomster:

export GITLAB_INSTANCE_URL=https://gitlab.company.com
export GITLAB_TOKEN=glpat-...

Hvis forekomsten din kjører en tilpasset AI-gateway:

GITLAB_AI_GATEWAY_URL=https://ai-gateway.company.com

Eller legg til bash-profilen din:

export GITLAB_INSTANCE_URL=https://gitlab.company.com
export GITLAB_AI_GATEWAY_URL=https://ai-gateway.company.com
export GITLAB_TOKEN=glpat-...

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:

export GITLAB_OAUTH_CLIENT_ID=your_application_id_here

Mer dokumentasjon på opencode-gitlab-auth hjemmeside.

Konfigurasjon

Tilpass gjennom 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.):

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

Kjør kommandoen /connect og søk etter GitHub Copilot.
```
/connect
```

Naviger til github.com/login/device og skriv inn koden.

┌ Login with GitHub Copilot
│
│ https://github.com/login/device
│
│ Enter code: 8F43-6FCF
│
└ Waiting for authorization...

Kjør nå kommandoen /models for å velge modellen du ønsker.
```
/models
```

Google Vertex AI

Slik bruker du Google Vertex AI med OpenCode:

Gå over til Model Garden i Google Cloud Console og sjekk modeller tilgjengelig i din region.

Du må ha et Google Cloud-prosjekt med Vertex AI API aktivert.
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.
Terminal window
```
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id opencode
```
Eller legg dem til på bash-profilen din.
~/.bash_profile
```
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
export GOOGLE_CLOUD_PROJECT=your-project-id
export VERTEX_LOCATION=global
```

Kjør kommandoen /models for å velge modellen du ønsker.
```
/models
```

Groq

Gå over til Groq-konsollen, klikk på Create API Key, og kopier nøkkelen.
Kjør kommandoen /connect og søk etter Groq.
```
/connect
```
Skriv inn API-nøkkelen for leverandøren.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge den du ønsker.
```
/models
```

Hugging Face

Hugging Face Inference Providers gir tilgang til åpne modeller som støttes av 17+ leverandører.

Gå over til Hugging Face-innstillinger for å opprette et token med tillatelse til å ringe til inferensleverandører.
Kjør kommandoen /connect og søk etter Hugging Face.
```
/connect
```
Skriv inn ditt Hugging Face-token.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell som Kimi-K2-Instruct eller GLM-4.6.
```
/models
```

Helicone

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

Gå over til Helicone, opprett en konto og generer en API nøkkel fra dashbordet.
Kjør kommandoen /connect og søk etter Helicone.
```
/connect
```
Skriv inn Helicone API-nøkkelen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell.
```
/models
```

For flere leverandører og avanserte funksjoner som bufring og hastighetsbegrensning, sjekk Helicone-dokumentasjonen.

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, du trenger denne for å hente ID-ene til modellene du vil legge til.

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

{
  "$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 funksjon lar deg gruppere relaterte LLM forespørsler sammen. Bruk opencode-helicone-session plugin for automatisk å logge hver OpenCode-samtale som en økt i Helicone.

npm install -g opencode-helicone-session

Legg den til i konfigurasjonen din.

{
  "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 for alle tilgjengelige overskrifter.

llama.cpp

Du kan konfigurere OpenCode for å bruke lokale modeller gjennom llama.cpp llama-server-verktøyet.

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

Gå over til IO.NET-konsollen, opprett en konto og generer en API-nøkkel.
Kjør kommandoen /connect og søk etter IO.NET.
```
/connect
```
Skriv inn nøkkelen IO.NET API.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell.
```
/models
```

LM Studio

Du kan konfigurere OpenCode for å bruke lokale modeller gjennom LM Studio.

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

Gå over til Moonshot AI-konsollen, opprett en konto og klikk på Opprett API-nøkkel.
Kjør kommandoen /connect og søk etter Moonshot AI.
```
/connect
```
Skriv inn Moonshot API-nøkkelen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge Kimi K2.
```
/models
```

MiniMax

Gå over til MiniMax API-konsollen, opprett en konto og generer en API-nøkkel.
Kjør kommandoen /connect og søk etter MiniMax.
```
/connect
```
Skriv inn MiniMax API-nøkkelen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell som M2.1.
```
/models
```

Nebius Token Factory

Gå over til Nebius Token Factory-konsollen, opprett en konto og klikk på Legg til nøkkel.
Kjør kommandoen /connect og søk etter Nebius Token Factory.
```
/connect
```
Skriv inn Nebius Token Factory API-nøkkelen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell som Kimi K2 Instruct.
```
/models
```

Ollama

Du kan konfigurere OpenCode for å bruke lokale modeller gjennom Ollama.

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

Ollama Cloud

Slik bruker du Ollama Cloud med OpenCode:

Gå over til https://ollama.com/ og logg på eller opprett en konto.
Naviger til Innstillinger > Nøkler og klikk på Legg til API nøkkel for å generere en ny API nøkkel.
Kopier API-nøkkelen for bruk i OpenCode.
Kjør kommandoen /connect og søk etter Ollama Cloud.
```
/connect
```
Skriv inn din Ollama Cloud API nøkkel.
```
┌ API key
│
│
└ enter
```
Viktig: Før du bruker skymodeller i OpenCode, må du hente modellinformasjonen lokalt:
Terminal window
```
ollama pull gpt-oss:20b-cloud
```
Kjør kommandoen /models for å velge din Ollama Cloud-modell.
```
/models
```

OpenAI

Vi anbefaler at du registrerer deg for ChatGPT Plus eller Pro.

Når du har registrert deg, kjør kommandoen /connect og velg OpenAI.
```
/connect
```
Her kan du velge alternativet ChatGPT Plus/Pro og det åpner nettleseren din og ber deg om å autentisere.
```
┌ Select auth method
│
│ ChatGPT Plus/Pro
│ Manually enter API Key
└
```
Nå skal alle OpenAI-modellene være tilgjengelige når du bruker kommandoen /models.
```
/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.

Logg på OpenCode Zen og klikk på Create API Key.
Kjør kommandoen /connect og søk etter OpenCode Zen.
```
/connect
```
Skriv inn OpenCode API-nøkkelen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell som Qwen 3 Coder 480B.
```
/models
```

OpenRouter

Gå over til OpenRouter-dashbordet, klikk på Create API Key, og kopier nøkkelen.
Kjør kommandoen /connect og søk etter OpenRouter.
```
/connect
```
Skriv inn API-nøkkelen for leverandøren.
```
┌ API key
│
│
└ enter
```
Mange OpenRouter-modeller er forhåndslastet som standard, kjør kommandoen /models for å velge den du ønsker.
```
/models
```
Du kan også legge til flere modeller gjennom OpenCode-konfigurasjonen.
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openrouter": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}
```

Du kan også tilpasse dem gjennom OpenCode-konfigurasjonen. Her er et eksempel på å spesifisere en leverandør

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

Gå til din SAP BTP Cockpit, naviger til din SAP AI kjernetjenesteforekomst, og lag en tjenestenøkkel.

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.
Kjør kommandoen /connect og søk etter SAP AI Core.
```
/connect
```

Skriv inn tjenestenøkkelen JSON.

┌ Service key
│
│
└ enter

Eller angi miljøvariabelen AICORE_SERVICE_KEY:

AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}' opencode

Eller legg den til bash-profilen din:

export AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}'

Angi eventuelt distribusjon ID og ressursgruppe:
Terminal window
```
AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode
```
Disse innstillingene er valgfrie og bør konfigureres i henhold til SAP AI kjerneoppsettet.
Kjør kommandoen /models for å velge fra 40+ tilgjengelige modeller.
```
/models
```

OVHcloud AI Endpoints

Gå over til OVHcloud-panelet. Naviger til Public Cloud-delen, AI & Machine Learning > AI Endpoints og i API Keys-fanen klikker du på Opprett en ny API-nøkkel.
Kjør kommandoen /connect og søk etter OVHcloud AI Endpoints.
```
/connect
```
Skriv inn OVHcloud AI Endpoints API nøkkel.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell som gpt-oss-120b.
```
/models
```

Scaleway

Slik bruker du Scaleway Generative APIs med OpenCode:

Gå over til Scaleway Console IAM innstillinger for å generere en ny API nøkkel.
Kjør kommandoen /connect og søk etter Scaleway.
```
/connect
```
Skriv inn Scaleway API-nøkkelen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell som devstral-2-123b-instruct-2512 eller gpt-oss-120b.
```
/models
```

Together AI

Gå over til Together AI-konsollen, opprett en konto og klikk på Legg til nøkkel.
Kjør kommandoen /connect og søk etter Together AI.
```
/connect
```
Skriv inn Together AI API nøkkelen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell som Kimi K2 Instruct.
```
/models
```

Venice AI

Gå over til Venice AI-konsollen, opprett en konto og generer en API-nøkkel.
Kjør kommandoen /connect og søk etter Venice AI.
```
/connect
```
Skriv inn Venice AI API-nøkkelen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell som Llama 3.3 70B.
```
/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.

Gå over til Vercel dashboard, naviger til fanen AI Gateway, og klikk på API nøkler for å opprette en ny API nøkkel.
Kjør kommandoen /connect og søk etter Vercel AI Gateway.
```
/connect
```
Skriv inn Vercel AI Gateway API nøkkel.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell.
```
/models
```

Du kan også tilpasse modeller gjennom OpenCode-konfigurasjonen. Her er et eksempel på spesifisering av leverandørrutingsrekkefølge.

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

Gå over til xAI-konsollen, opprett en konto og generer en API-nøkkel.
Kjør kommandoen /connect og søk etter xAI.
```
/connect
```
Skriv inn xAI API-nøkkelen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell som Grok Beta.
```
/models
```

Z.AI

Gå over til Z.AI API-konsollen, opprett en konto og klikk på Opprett en ny API-nøkkel.
Kjør kommandoen /connect og søk etter Z.AI.
```
/connect
```
Hvis du abonnerer på GLM Coding Plan, velg Z.AI Coding Plan.
Skriv inn Z.AI API-nøkkelen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for å velge en modell som GLM-4.7.
```
/models
```

ZenMux

Gå over til ZenMux-dashbordet, klikk på Create API Key, og kopier nøkkelen.
Kjør kommandoen /connect og søk etter ZenMux.
```
/connect
```
Skriv inn API-nøkkelen for leverandøren.
```
┌ API key
│
│
└ enter
```
Mange ZenMux-modeller er forhåndslastet som standard, kjør kommandoen /models for å velge den du ønsker.
```
/models
```
Du kan også legge til flere modeller gjennom OpenCode-konfigurasjonen.
opencode.json
```
{
  "$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:

Kjør kommandoen /connect og rull ned til Annet.

$ /connect

┌  Add credential
│
◆  Select provider
│  ...
│  ● Other
└

Skriv inn en unik ID for leverandøren.
Terminal window
```
$ /connect

┌  Add credential
│
◇  Enter provider id
│  myprovider
└
```
Velg en minneverdig ID, du vil bruke denne i konfigurasjonsfilen din.

Skriv inn API-nøkkelen for leverandøren.

$ /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-...
└

Opprett eller oppdater opencode.json-filen i prosjektkatalogen:
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "myprovider": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "My AI ProviderDisplay Name",
      "options": {
        "baseURL": "https://api.myprovider.com/v1"
      },
      "models": {
        "my-model-name": {
          "name": "My Model Display Name"
        }
      }
    }
  }
}
```
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.
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.

{
  "$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.
overskrifter: Egendefinerte overskrifter 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:

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