Buckets:

GHHG10
/

CodeServer

Files

xet

GHHG10/CodeServer / opencode /packages /web /src /content /docs /nb /providers.mdx

GHHG10

about 2 months ago

download

raw

46.9 kB

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

	---

	### FrogBot

	1. Gå over til [FrogBot dashboard](https://app.frogbot.ai/signup), opprett en konto og generer en API nøkkel.

	2. Kjør kommandoen `/connect` og søk etter FrogBot.

	```txt
	/connect
	```

	3. Skriv inn frogbot 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.

Xet Storage Details

Size:: 46.9 kB
Xet hash:: 1e1061d6d80f30d2d06157811a01eabb3d22b52c1bca20bae9f4bba6f8b85aed

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.