Leverandører

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

OpenCode bruger AI SDK og Models.dev for at støtte 75+ LLM leverandører og den støtter kjøring av lokale modeller.

For at tilføje til en leverandør må du:

Legg til API-nøklene for leverandøren ved at bruge kommandoen /connect.
Konfigurer leverandøren i OpenCode-konfigurasjonen.

Legitimasjon

Når du tilføjer 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 at angi alternativet baseURL. Dette er nyttig når du bruger 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 at fungere godt med OpenCode. Finn ut mer.

Kjør kommandoen /connect i TUI, velg opencode og gå til opencode.ai/auth.
```
/connect
```
Logg på, tilføj til faktureringsdetaljene dine og kopier API-nøgleen.
Lim inn API-nøgleen.
```
┌ API key
│
│
└ enter
```
Kjør /models i TUI for at se listen over modeller vi anbefaler.
```
/models
```

Det fungerer som alle andre leverandører i OpenCode og er helt valgfritt at bruge.

Katalog

La oss se på nogle av leverandørene i detalj. Hvis du vil tilføje til en leverandør til liste, åpne gjerne en PR.

302.AI

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

Amazonas grunnfjell

Slik bruger 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 at bruge 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 tilføj 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, brug 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 bruger VPC endepunkter for Berggrunn:
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 at bruge AWS-spesifikk terminologi. Hvis både endpoint og baseURL er spesifisert, har endpoint forrang.

Autentiseringsmetoder
- AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY: Opret en IAM-bruger og generer tilgangsnøkler i AWS-konsollen
- AWS_PROFILE: Brug 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 bruger tjenestekontokommentarer.
Autentiseringsprioritet

Amazon Bedrock bruger 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 at velge modellen du ønsker.
```
/models
```

For egendefinerte slutningsprofiler, brug 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"
        }
      }
    }
  }
}

Antropisk

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

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

Bruge API-tastene

Du kan også velge Opret en API-nøgle 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øgle, kan du velge Angi API-nøgle 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øgle: 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øgleen.
```
┌ API key
│
│
└ enter
```
Angi ressursnavnet ditt som en miljøvariabel:
Terminal window
```
AZURE_RESOURCE_NAME=XXX opencode
```
Eller tilføj den til bash-profilen din:
~/.bash_profile
```
export AZURE_RESOURCE_NAME=XXX
```
Kjør kommandoen /models for at 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øgle: 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øgleen.
```
┌ API key
│
│
└ enter
```
Angi ressursnavnet ditt som en miljøvariabel:
Terminal window
```
AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
```
Eller tilføj den til bash-profilen din:
~/.bash_profile
```
export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX
```
Kjør kommandoen /models for at velge den distribuerte modellen.
```
/models
```

Baseten

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

Cerebras

Gå over til Cerebras-konsollen, opret en konto og generer en API-nøgle.
Kjør kommandoen /connect og søk etter Cerebras.
```
/connect
```
Skriv inn Cerebras API-nøgleen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for at 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 at velge en modell.

/models

Du kan også tilføje 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, opret en konto og generer en API-nøgle.
Kjør kommandoen /connect og søk etter Cortecs.
```
/connect
```
Skriv inn Cortecs API-nøgleen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for at velge en modell som Kimi K2 Instruct.
```
/models
```

DeepSeek

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

Deep Infra

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

Fastvare

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

Fyrverkeri AI

Gå over til Fireworks AI-konsollen, opret 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øgleen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for at velge en modell som Kimi K2 Instruct.
```
/models
```

GitLab Duo

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

Kjør kommandoen /connect og velg GitLab.
```
/connect
```
Velg autentiseringsmetoden din:
```
┌ Select auth method
│
│ OAuth (Recommended)
│ Personal Access Token
└
```
Bruge OAuth (anbefalt)

Velg OAuth og nettleseren din åpnes for autorisasjon.

Bruger 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 at se tilgængelige modeller.
```
/models
```
Tre Claude-baserte modeller er tilgængelige:
- 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 bruger en liten modell for nogle AI oppgaver som at generere sessiontittelen. Den er konfigurert til at bruge gpt-5-nano som standard, hostet av Zen. For at låse OpenCode for kun at bruge din egen GitLab-hostede forekomst, tilføj til følgende i din opencode.json fil. Det anbefales også at deaktivere sessiondeling.

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

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

Eller tilføj 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 at få Oauth til at fungere for din selvhostede forekomst, må du oprete en ny applikasjon (Innstillinger → Programmer) med callback 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 at 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 bruger 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 at velge modellen du ønsker.
```
/models
```

Google Vertex AI

Slik bruger du Google Vertex AI med OpenCode:

Gå over til Model Garden i Google Cloud Console og tjek modeller tilgængelig 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 tilføj 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 at 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øgleen for leverandøren.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for at velge den du ønsker.
```
/models
```

Klemmer ansikt

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

Gå over til Hugging Face-innstillinger for at oprete et token med tillatelse til at 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 at velge en modell som Kimi-K2-Instruct eller GLM-4.6.
```
/models
```

Helikon

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, opret en konto og generer en API-nøgle fra dashbordet.
Kjør kommandoen /connect og søk etter Helicone.
```
/connect
```
Skriv inn Helicone API-nøgleen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for at velge en modell.
```
/models
```

For flere leverandører og avanserte funksjoner som bufring og hastighetsbegrensning, tjek 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 at hente ID-ene til modellene du vil tilføje 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, brugersporing og sessionadministrasjon. Legg dem til leverandørkonfigurasjonen din ved at bruge 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. Brug opencode-helicone-session plugin for automatisk at logge hver OpenCode-samtale som en session i Helicone.

npm install -g opencode-helicone-session

Legg den til i konfigurasjonen din.

{
  "plugin": ["opencode-helicone-session"]
}

Programtiltilføjet 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 session.

Vanlige helikonhoder

Overskrift	Beskrivelse
`Helicone-Cache-Enabled`	Aktiver responsbufring (`true`/`false`)
`Helicone-User-Id`	Spor beregninger etter bruger
`Helicone-Property-[Name]`	Legg til egendefinerte egenskaper (f.eks. `Helicone-Property-Environment`)
`Helicone-Prompt-Id`	Knytt forespørsler til spørsmålsversioner

Se Helicone Header Directory for alle tilgængelige overskrifter.

lama.cpp

Du kan konfigurere opencode for at bruge lokale modeller gjennom llama.cpps lama-server-verktøy

{
  "$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 bruges for denne leverandøren. Her bruges @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 brugstilfeller:

Gå over til IO.NET-konsollen, opret en konto og generer en API-nøgle.
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 at velge en modell.
```
/models
```

LM Studio

Du kan konfigurere opencode for at bruge 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 bruges for denne leverandøren. Her bruges @ai-sdk/openai-compatible for enhver OpenAI-kompatibel API.
name er visningsnavnet for leverandøren i UI.
options.baseURL er endepunktet for den lokale serveren.
models er et kart over modell-ID-er til deres konfigurasjoner. Modellnavnet vil vises i modellvalglisten.

Måneskudd AI

Slik bruger du Kimi K2 fra Moonshot AI:

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

MiniMax

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

Nebius Token Factory

Gå over til Nebius Token Factory-konsollen, opret 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øgleen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for at velge en modell som Kimi K2 Instruct.
```
/models
```

Ollama

Du kan konfigurere opencode for at bruge 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 bruges for denne leverandøren. Her bruges @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 bruger du Ollama Cloud med OpenCode:

Gå over til https://ollama.com/ og logg på eller opret en konto.
Naviger til Innstillinger > Nøkler og klikk på Legg til API-nøgle for at generere en ny API-nøgle.
Kopier API-nøgleen for brug i OpenCode.
Kjør kommandoen /connect og søk etter Ollama Cloud.
```
/connect
```
Skriv inn din Ollama Cloud API-nøgle.
```
┌ API key
│
│
└ enter
```
Viktig: Før du bruger skymodeller i OpenCode, må du hente modellinformasjonen lokalt:
Terminal window
```
ollama pull gpt-oss:20b-cloud
```
Kjør kommandoen /models for at 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 at autentisere.
```
┌ Select auth method
│
│ ChatGPT Plus/Pro
│ Manually enter API Key
└
```
Nå skal alle OpenAI-modellene være tilgængelige når du bruger kommandoen /models.
```
/models
```

Bruge API-tastene

Hvis du allerede har en API-nøgle, kan du velge Angi API-nøgle 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øgleen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for at 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øgleen for leverandøren.
```
┌ API key
│
│
└ enter
```
Mange OpenRouter-modeller er forhåndslastet som standard, kjør kommandoen /models for at velge den du ønsker.
```
/models
```
Du kan også tilføje 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å at 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 Kjerne

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 cockpiten.
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 tilføj 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 at velge fra 40+ tilgængelige modeller.
```
/models
```

OVHcloud AI endepunkter

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

Scaleway

Slik bruger du Scaleway Generative APIs med OpenCode:

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

Sammen AI

Gå over til Together AI-konsollen, opret 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øgleen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for at velge en modell som Kimi K2 Instruct.
```
/models
```

Venezia AI

Gå over til Venezia AI-konsollen, opret en konto og generer en API-nøgle.
Kjør kommandoen /connect og søk etter Venezia AI.
```
/connect
```
Skriv inn Venezia AI API-nøgleen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for at 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 at oprete en ny API-nøgle.
Kjør kommandoen /connect og søk etter Vercel AI Gateway.
```
/connect
```
Skriv inn Vercel AI Gateway API-nøgle.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for at 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"]
          }
        }
      }
    }
  }
}

Nogle nyttige rutealternativer:

Alternativ	Beskrivelse
`order`	Providersekvens for at prøve
`only`	Begrens til spesifikke leverandører
`zeroDataRetention`	Brug kun leverandører med null retningslinjer for datalagring

xAI

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

Z.AI

Gå over til Z.AI API-konsollen, opret en konto og klikk på Opret en ny API-nøgle.
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øgleen.
```
┌ API key
│
│
└ enter
```
Kjør kommandoen /models for at 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øgleen for leverandøren.
```
┌ API key
│
│
└ enter
```
Mange ZenMux-modeller er forhåndslastet som standard, kjør kommandoen /models for at velge den du ønsker.
```
/models
```
Du kan også tilføje til flere modeller gjennom opencode-konfigurasjonen.
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "zenmux": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}
```

Egendefinert leverandør

Slik tilføjer 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 bruge denne i konfigurasjonsfilen din.

Skriv inn API-nøgleen 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-...
└

Opret eller opdater 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 at bruge, @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øgleen hvis du ikke bruger 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 inndatatoken som modellen godtar.
limit.output: Maksimalt antall tokens modellen kan generere.

limit-feltene lar OpenCode forstå hvor mye kontekst du har igjen. Standardleverandører henter disse automatisk fra models.dev.

Feilsøking

Hvis du har problemer med at konfigurere en leverandør, tjek følgende:

Tjek autentiseringsoppsettet: Kjør opencode auth list for at se om legitimasjonen for leverandøren tilføjes til konfigurasjonen din.

Dette gjelder ikke leverandører som Amazon Bedrock, som er avhengige av miljøvariabler for godkjenning.
For tilpassede leverandører, tjek opencode-konfigurasjonen og:
- Sørg for at leverandøren ID som bruges i /connect-kommandoen samsvarer med ID i opencode-konfigurasjonen. – Den riktige npm-pakken bruges for leverandøren. Brug for eksempel @ai-sdk/cerebras for Cerebras. Og for alle andre OpenAI-kompatible leverandører, brug @ai-sdk/openai-compatible.
- Kontroller at riktig API-endepunkt er brugt i options.baseURL-feltet.