Udbydere

Brug en hvilken som helst LLM-udbyder i OpenCode.

OpenCode bruger AI SDK og Models.dev til at understøtte 75+ LLM-udbydere og understøtter kørsel af lokale modeller.

For at tilføje en udbyder skal du:

Tilføje API-nøglerne for udbyderen ved at bruge kommandoen /connect.
Konfigurere udbyderen i OpenCode-konfigurationen.

Legitimationsoplysninger

Når du tilføjer en udbyders API-nøgler med /connect-kommandoen, gemmes de i ~/.local/share/opencode/auth.json.

Konfiguration

Du kan tilpasse udbyderne gennem provider-delen i OpenCode-konfigurationen.

Base URL

Du kan tilpasse base URL for enhver udbyder ved at angive muligheden baseURL. Dette er nyttigt, når du bruger proxy-tjenester eller tilpassede endpoints.

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "anthropic": {
      "options": {
        "baseURL": "https://api.anthropic.com/v1"
      }
    }
  }
}

OpenCode Zen

OpenCode Zen er en liste over modeller leveret af OpenCode-teamet, som er blevet testet og verificeret til at fungere godt med OpenCode. Læs mere.

Kør kommandoen /connect i TUI, vælg opencode og gå til opencode.ai/auth.
```
/connect
```
Log ind, tilføj dine faktureringsoplysninger og kopier API-nøglen.
Indsæt API-nøglen.
```
┌ API key
│
│
└ enter
```
Kør /models i TUI for at se listen over modeller, vi anbefaler.
```
/models
```

Det fungerer som alle andre udbydere i OpenCode og er helt valgfrit at bruge.

Katalog

Lad os se på nogle af udbyderne i detaljer. Hvis du vil tilføje en udbyder til listen, er du velkommen til at åbne en PR.

302.AI

Gå til 302.AI-konsollen, opret en konto og generer en API-nøgle.
Kør kommandoen /connect og søg efter 302.AI.
```
/connect
```
Indtast 302.AI API-nøglen.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model.
```
/models
```

Amazon Bedrock

Sådan bruger du Amazon Bedrock med OpenCode:

Gå til modelkataloget i Amazon Bedrock-konsollen og anmod om adgang til de modeller, du ønsker.

Du skal have adgang til modellen du ønsker i Amazon Bedrock.
Konfigurer godkendelse ved at bruge en af følgende metoder:

Miljøvariabler (hurtigstart)

Angiv en af disse miljøvariabler, mens du kø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 din bash-profil:
~/.bash_profile
```
export AWS_PROFILE=my-dev-profile
export AWS_REGION=us-east-1
```
Konfigurationsfil (anbefalet)

For projektspecifik eller vedvarende konfiguration, brug opencode.json:
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "amazon-bedrock": {
      "options": {
        "region": "us-east-1",
        "profile": "my-aws-profile"
      }
    }
  }
}
```
Tilgængelige muligheder:
- region - AWS region (f.eks. us-east-1, eu-west-1)
- profile - AWS navngivet profil fra ~/.aws/credentials
- endpoint - Brugerdefineret endpoint URL for VPC endpoints (alias for generisk baseURL-mulighed)
Konfigurationsfil-muligheder har forrang over miljøvariabler.

Avanceret: VPC Endpoints

Hvis du bruger VPC endpoints 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"
      }
    }
  }
}
```
Muligheden endpoint er et alias for den generiske mulighed baseURL, der bruger AWS-specifik terminologi. Hvis både endpoint og baseURL er specificeret, har endpoint forrang.

Godkendelsesmetoder
- AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY: Opret en IAM-bruger og generer adgangsnøgler i AWS-konsollen
- AWS_PROFILE: Brug navngivne profiler fra ~/.aws/credentials. Konfigurer først med aws configure --profile my-profile eller aws sso login
- AWS_BEARER_TOKEN_BEDROCK: Generer langsigtede API-nøgler fra Amazon Bedrock-konsollen
- AWS_WEB_IDENTITY_TOKEN_FILE / AWS_ROLE_ARN: For EKS IRSA (IAM roller for tjenestekonti) eller andre Kubernetes-miljøer med OIDC føderation. Disse miljøvariabler injiceres automatisk af Kubernetes, når du bruger tjenestekontokommentarer.
Godkendelsesprioritet

Amazon Bedrock bruger følgende godkendelsesprioritet:
1. Bearer Token - AWS_BEARER_TOKEN_BEDROCK miljøvariabel eller token fra kommandoen /connect
2. AWS legitimationskæde - profil, adgangsnøgler, delte legitimationsoplysninger, IAM roller, webidentitetstokens (EKS IRSA), instansmetadata
Når et bearer token er angivet (via /connect eller AWS_BEARER_TOKEN_BEDROCK), har det forrang over alle AWS godkendelsesmetoder inklusiv konfigurerede profiler.
Kør kommandoen /models for at vælge den model, du ønsker.
```
/models
```

For brugerdefinerede inferensprofiler, brug modellen og udbydernavnet i nøglen og sæt egenskaben 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 registreret dig, kør kommandoen /connect og vælg Anthropic.
```
/connect
```
Her kan du vælge muligheden Claude Pro/Max, og det vil åbne din browser og bede dig om at godkende.
```
┌ Select auth method
│
│ Claude Pro/Max
│ Create an API Key
│ Manually enter API Key
└
```
Nu skal alle de Anthropiske modeller være tilgængelige, når du bruger kommandoen /models.
```
/models
```

At bruge dit Claude Pro/Max-abonnement i OpenCode understøttes ikke officielt af Anthropic.

Brug API-nøgler

Du kan også vælge Create an API Key, hvis du ikke har et Pro/Max-abonnement. Det åbner også din browser og beder dig logge på Anthropic og giver dig en kode, du kan indsætte i din terminal.

Eller hvis du allerede har en API-nøgle, kan du vælge Manually enter API Key og indsætte den i terminalen.

Azure OpenAI

Gå til Azure-portalen og opret en Azure OpenAI-ressource. Du skal bruge:
- Ressourcenavn: Dette bliver en del af API-endpointet (https://RESOURCE_NAME.openai.azure.com/)
- API-nøgle: Enten KEY 1 eller KEY 2 fra din ressource
Gå til Azure AI Foundry og distribuer en model.

Distributionsnavnet skal matche modelnavnet for at opencode skal fungere korrekt.
Kør kommandoen /connect og søg efter Azure.
```
/connect
```
Indtast API-nøglen.
```
┌ API key
│
│
└ enter
```
Angiv dit ressourcenavn som en miljøvariabel:
Terminal window
```
AZURE_RESOURCE_NAME=XXX opencode
```
Eller tilføj den til din bash-profil:
~/.bash_profile
```
export AZURE_RESOURCE_NAME=XXX
```
Kør kommandoen /models for at vælge den distribuerede model.
```
/models
```

Azure Cognitive Services

Gå til Azure-portalen og opret en Azure OpenAI-ressource. Du skal bruge:
- Ressourcenavn: Dette bliver en del af API-endpointet (https://AZURE_COGNITIVE_SERVICES_RESOURCE_NAME.cognitiveservices.azure.com/)
- API-nøgle: Enten KEY 1 eller KEY 2 fra din ressource
Gå til Azure AI Foundry og distribuer en model.

Distributionsnavnet skal matche modelnavnet for at opencode skal fungere korrekt.
Kør kommandoen /connect og søg efter Azure Cognitive Services.
```
/connect
```
Indtast API-nøglen.
```
┌ API key
│
│
└ enter
```
Angiv dit ressourcenavn som en miljøvariabel:
Terminal window
```
AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
```
Eller tilføj den til din bash-profil:
~/.bash_profile
```
export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX
```
Kør kommandoen /models for at vælge den distribuerede model.
```
/models
```

Baseten

Gå til Baseten, opret en konto og generer en API-nøgle.
Kør kommandoen /connect og søg efter Baseten.
```
/connect
```
Indtast din Baseten API-nøgle.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model.
```
/models
```

Cerebras

Gå til Cerebras-konsollen, opret en konto og generer en API-nøgle.
Kør kommandoen /connect og søg efter Cerebras.
```
/connect
```
Indtast Cerebras API-nøglen.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model som Qwen 3 Coder 480B.
```
/models
```

Cloudflare AI Gateway

Cloudflare AI Gateway lader dig få adgang til modeller fra OpenAI, Anthropic, Workers AI og flere gennem et samlet endpoint. Med Unified Billing behøver du ikke separate API-nøgler for hver udbyder.

Gå til Cloudflare-dashboardet, naviger til AI > AI Gateway, og opret en ny gateway.

Angiv konto-ID og gateway-ID som miljøvariabler.

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

Kør kommandoen /connect og søg efter Cloudflare AI Gateway.
```
/connect
```
Indtast din Cloudflare API-token.
```
┌ API key
│
│
└ enter
```
Eller angiv den som en miljøvariabel.
~/.bash_profile
```
export CLOUDFLARE_API_TOKEN=your-api-token
```

Kør kommandoen /models for at vælge en model.

/models

Du kan også tilføje modeller gennem opencode-konfigurationen.

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

Cortecs

Gå til Cortecs-konsollen, opret en konto og generer en API-nøgle.
Kør kommandoen /connect og søg efter Cortecs.
```
/connect
```
Indtast Cortecs API-nøglen.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model som Kimi K2 Instruct.
```
/models
```

DeepSeek

Gå til DeepSeek-konsollen, opret en konto og klik på Create API Key.
Kør kommandoen /connect og søg efter DeepSeek.
```
/connect
```
Indtast DeepSeek API-nøglen.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en DeepSeek-model som DeepSeek Reasoner.
```
/models
```

Deep Infra

Gå til Deep Infra-dashboardet, opret en konto og generer en API-nøgle.
Kør kommandoen /connect og søg efter Deep Infra.
```
/connect
```
Indtast Deep Infra API-nøglen.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model.
```
/models
```

Firmware

Gå til Firmware dashboard, opret en konto og generer en API-nøgle.
Kør kommandoen /connect og søg efter Firmware.
```
/connect
```
Indtast firmware API-nøglen.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model.
```
/models
```

Fireworks AI

Gå til Fireworks AI-konsollen, opret en konto og klik på Create API Key.
Kør kommandoen /connect og søg efter Fireworks AI.
```
/connect
```
Indtast Fireworks AI API-nøglen.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model som Kimi K2 Instruct.
```
/models
```

GitLab Duo

GitLab Duo giver AI-drevet agentchat med native værktøjskaldsfunktioner gennem GitLabs anthropiske proxy.

Kør kommandoen /connect og vælg GitLab.
```
/connect
```
Vælg din godkendelsesmetode:
```
┌ Select auth method
│
│ OAuth (Recommended)
│ Personal Access Token
└
```
Brug OAuth (anbefalet)

Vælg OAuth og din browser åbner for autorisation.

Brug personlig adgangstoken
1. Gå til GitLab User Settings > Access Tokens
2. Klik på Add new token
3. Navn: OpenCode, omfang: api
4. Kopier tokenet (starter med glpat-)
5. Indtast den i terminalen
Kør kommandoen /models for at se tilgængelige modeller.
```
/models
```
Tre Claude-baserede modeller er tilgængelige:
- duo-chat-haiku-4-5 (standard) - Hurtige svar til hurtige opgaver
- duo-chat-sonnet-4-5 - Balanceret ydeevne til de fleste arbejdsgange
- duo-chat-opus-4-5 - Mest egnet til kompleks analyse

OpenCode bruger en lille model til nogle AI-opgaver som at generere sessionstitlen. Den er konfigureret til at bruge gpt-5-nano som standard, hostet af Zen. For at låse OpenCode til kun at bruge din egen GitLab-hostede instans, tilføj følgende i din opencode.json fil. Det anbefales også at deaktivere sessionsdeling.

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

For selvhostede GitLab-instanser:

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

Hvis din instans kører en brugerdefineret AI-gateway:

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

Eller tilføj til din bash-profil:

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

OAuth for selvhostede instanser

For at få Oauth til at fungere for din selvhostede instans, skal du oprette en ny applikation (Indstillinger → Applikationer) med callback URL http://127.0.0.1:8080/callback og følgende omfang:

api (Få adgang til API på dine vegne)
read_user (Læs din personlige information)
read_repository (tillader skrivebeskyttet adgang til depotet)

Udsæt derefter applikations-ID som miljøvariabel:

export GITLAB_OAUTH_CLIENT_ID=your_application_id_here

Mere dokumentation på opencode-gitlab-auth hjemmesiden.

Konfiguration

Tilpas gennem 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-værktøjer (valgfrit, men stærkt anbefalet)

For at få adgang til GitLab-værktøjer (merge requests, problemer, pipelines, CI/CD, etc.):

{
  "$schema": "https://opencode.ai/config.json",
  "plugin": ["@gitlab/opencode-gitlab-plugin"]
}

Denne plugin giver omfattende GitLab-repository-administrationsfunktioner, inklusiv MR-anmeldelser, problemsporing, pipeline-overvågning og mere.

GitHub Copilot

Sådan bruger du GitHub Copilot-abonnementet med OpenCode:

Kør kommandoen /connect og søg efter GitHub Copilot.
```
/connect
```

Naviger til github.com/login/device og indtast koden.

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

Kør nu kommandoen /models for at vælge modellen du ønsker.
```
/models
```

Google Vertex AI

Sådan bruger du Google Vertex AI med OpenCode:

Gå til Model Garden i Google Cloud Console og tjek modeller tilgængelig i din region.

Du skal have et Google Cloud-projekt med Vertex AI API aktiveret.
Angiv de nødvendige miljøvariabler:
- GOOGLE_CLOUD_PROJECT: Dit Google Cloud-projekt ID
- VERTEX_LOCATION (valgfrit): Regionen for Vertex AI (standard til global)
- Godkendelse (vælg en):
  - GOOGLE_APPLICATION_CREDENTIALS: Sti til tjenestekontoens JSON-nøglefil
  - Godkend med gcloud CLI: gcloud auth application-default login
Sæt dem mens du kører opencode.
Terminal window
```
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id opencode
```
Eller tilføj dem til din bash-profil.
~/.bash_profile
```
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
export GOOGLE_CLOUD_PROJECT=your-project-id
export VERTEX_LOCATION=global
```

Kør kommandoen /models for at vælge modellen du ønsker.
```
/models
```

Groq

Gå til Groq-konsollen, klik på Create API Key, og kopier nøglen.
Kør kommandoen /connect og søg efter Groq.
```
/connect
```
Indtast API-nøglen for udbyderen.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge den du ønsker.
```
/models
```

Hugging Face

Hugging Face Inference Providers giver adgang til åbne modeller som støttes af 17+ udbydere.

Gå til Hugging Face-indstillinger for at oprette et token med tilladelse til at kalde inferensudbydere.
Kør kommandoen /connect og søg efter Hugging Face.
```
/connect
```
Indtast dit Hugging Face-token.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model som Kimi-K2-Instruct eller GLM-4.6.
```
/models
```

Helicone

Helicone er en LLM observerbarhedsplatform som giver logning, overvågning og analyser for dine AI-applikationer. Helicone AI Gateway ruter dine anmodninger til den rigtige udbyder automatisk baseret på modellen.

Gå til Helicone, opret en konto og generer en API-nøgle fra dashboardet.
Kør kommandoen /connect og søg efter Helicone.
```
/connect
```
Indtast Helicone API-nøglen.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model.
```
/models
```

For flere udbydere og avancerede funktioner som caching og hastighedsbegrænsning, tjek Helicone-dokumentationen.

Valgfrie konfigurationer

I tilfælde af at du ser en funktion eller model fra Helicone som ikke konfigureres automatisk gennem opencode, kan du altid konfigurere den selv.

Her er Helicone’s Model Directory, du skal bruge denne for at hente ID’erne til de modeller du vil tilføje.

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

Brugerdefinerede headers

Helicone understøtter tilpassede headers for funktioner som caching, brugersporing og sessionsadministration. Læg dem til din udbyderkonfiguration 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",
        },
      },
    },
  },
}

Sessionssporing

Helicones Sessions funktion lader dig gruppe relaterede LLM anmodninger sammen. Brug opencode-helicone-session plugin for automatisk at logge hver OpenCode-samtale som en session i Helicone.

npm install -g opencode-helicone-session

Tilføj den til din konfiguration.

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

Programmatisk injicerer Helicone-Session-Id og Helicone-Session-Name headers i dine anmodninger. På Helicones Sessions-side vil du se hver OpenCode-samtale opført som en separat session.

Almindelige Helicone-headers

Header	Beskrivelse
`Helicone-Cache-Enabled`	Aktiver respons-caching (`true`/`false`)
`Helicone-User-Id`	Spor beregninger efter bruger
`Helicone-Property-[Name]`	Tilføj egendefinerede egenskaber (f.eks. `Helicone-Property-Environment`)
`Helicone-Prompt-Id`	Knyt anmodninger til prompt-versioner

Se Helicone Header Directory for alle tilgængelige headers.

llama.cpp

Du kan konfigurere opencode til at bruge lokale modeller gennem llama.cpps llama-server-værktøj

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

llama.cpp er den tilpassede udbyder ID. Dette kan være hvilken som helst streng du vil.
npm specificerer pakken som skal bruges for denne udbyder. Her bruges @ai-sdk/openai-compatible for enhver OpenAI-kompatibel API.
name er visningsnavnet for udbyderen i UI.
options.baseURL er endpointet for den lokale server.
models er et kort over model-ID’er til deres konfigurationer. Modelnavnet vil vises i modelvalglisten.

IO.NET

IO.NET tilbyder 17 modeller optimeret for forskellige brugstilfælde:

Gå til IO.NET-konsollen, opret en konto og generer en API-nøgle.
Kør kommandoen /connect og søg efter IO.NET.
```
/connect
```
Indtast nøglen IO.NET API.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model.
```
/models
```

LM Studio

Du kan konfigurere opencode til at bruge lokale modeller gennem 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 eksempel:

lmstudio er den tilpassede udbyder ID. Dette kan være hvilken som helst streng du vil.
npm specificerer pakken som skal bruges for denne udbyder. Her bruges @ai-sdk/openai-compatible for enhver OpenAI-kompatibel API.
name er visningsnavnet for udbyderen i UI.
options.baseURL er endpointet for den lokale server.
models er et kort over model-ID’er til deres konfigurationer. Modelnavnet vil vises i modelvalglisten.

Moonshot AI

Sådan bruger du Kimi K2 fra Moonshot AI:

Gå til Moonshot AI-konsollen, opret en konto og klik på Create API Key.
Kør kommandoen /connect og søg efter Moonshot AI.
```
/connect
```
Indtast Moonshot API-nøglen.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge Kimi K2.
```
/models
```

MiniMax

Gå til MiniMax API-konsollen, opret en konto og generer en API-nøgle.
Kør kommandoen /connect og søg efter MiniMax.
```
/connect
```
Indtast MiniMax API-nøglen.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model som M2.1.
```
/models
```

Nebius Token Factory

Gå til Nebius Token Factory-konsollen, opret en konto og klik på Add Key.
Kør kommandoen /connect og søg efter Nebius Token Factory.
```
/connect
```
Indtast Nebius Token Factory API-nøglen.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model som Kimi K2 Instruct.
```
/models
```

Ollama

Du kan konfigurere opencode til at bruge lokale modeller gennem 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 eksempel:

ollama er den tilpassede udbyder ID. Dette kan være hvilken som helst streng du vil.
npm specificerer pakken som skal bruges for denne udbyder. Her bruges @ai-sdk/openai-compatible for enhver OpenAI-kompatibel API.
name er visningsnavnet for udbyderen i UI.
options.baseURL er endpointet for den lokale server.
models er et kort over model-ID’er til deres konfigurationer. Modelnavnet vil vises i modelvalglisten.

Ollama Cloud

Sådan bruger du Ollama Cloud med OpenCode:

Gå til https://ollama.com/ og log på eller opret en konto.
Naviger til Settings > Keys og klik på Add API Key for at generere en ny API-nøgle.
Kopier API-nøglen til brug i OpenCode.
Kør kommandoen /connect og søg efter Ollama Cloud.
```
/connect
```
Indtast din Ollama Cloud API-nøgle.
```
┌ API key
│
│
└ enter
```
Vigtigt: Før du bruger skymodeller i OpenCode, skal du hente modelinformationen lokalt:
Terminal window
```
ollama pull gpt-oss:20b-cloud
```
Kør kommandoen /models for at vælge din Ollama Cloud-model.
```
/models
```

OpenAI

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

Når du har registreret dig, kør kommandoen /connect og vælg OpenAI.
```
/connect
```
Her kan du vælge muligheden ChatGPT Plus/Pro og det åbner din browser og beder dig om at godkende.
```
┌ Select auth method
│
│ ChatGPT Plus/Pro
│ Manually enter API Key
└
```
Nu skal alle OpenAI-modellerne være tilgængelige, når du bruger kommandoen /models.
```
/models
```

Brug API-nøgler

Hvis du allerede har en API-nøgle, kan du vælge Manually enter API Key og indsætte den i terminalen.

OpenCode Zen

OpenCode Zen er en liste over testede og verificerede modeller leveret af OpenCode-teamet. Læs mere.

Log på OpenCode Zen og klik på Create API Key.
Kør kommandoen /connect og søg efter OpenCode Zen.
```
/connect
```
Indtast OpenCode API-nøglen.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model som Qwen 3 Coder 480B.
```
/models
```

OpenRouter

Gå til OpenRouter-dashboardet, klik på Create API Key, og kopier nøglen.
Kør kommandoen /connect og søg efter OpenRouter.
```
/connect
```
Indtast API-nøglen for udbyderen.
```
┌ API key
│
│
└ enter
```
Mange OpenRouter-modeller er forudindlæst som standard, kør kommandoen /models for at vælge den du ønsker.
```
/models
```
Du kan også tilføje flere modeller gennem opencode-konfigurationen.
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openrouter": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}
```

Du kan også tilpasse dem gennem opencode-konfigurationen. Her er et eksempel på at specificere en udbyder

{
  "$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 giver adgang til 40+ modeller fra OpenAI, Anthropic, Google, Amazon, Meta, Mistral og AI21 gennem en samlet platform.

Gå til din SAP BTP Cockpit, naviger til din SAP AI kerne-tjenesteinstans, og opret en tjenestenøgle.

Tjenestenøglen er et JSON-objekt som indeholder clientid, clientsecret, url og serviceurls.AI_API_URL. Du finder din AI-kerneinstans under Services > Instances and Subscriptions i BTP cockpittet.
Kør kommandoen /connect og søg efter SAP AI Core.
```
/connect
```

Indtast tjenestenøglen JSON.

┌ Service key
│
│
└ enter

Eller angiv miljøvariablen AICORE_SERVICE_KEY:

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

Eller tilføj den til din bash-profil:

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

Angiv eventuelt deployment-ID og ressourcegruppe:
Terminal window
```
AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode
```
Disse indstillinger er valgfrie og bør konfigureres i henhold til SAP AI kerne-opsætningen.
Kør kommandoen /models for at vælge fra 40+ tilgængelige modeller.
```
/models
```

OVHcloud AI Endpoints

Gå 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.
Kør kommandoen /connect og søg efter OVHcloud AI Endpoints.
```
/connect
```
Indtast OVHcloud AI Endpoints API-nøgle.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model som gpt-oss-120b.
```
/models
```

Scaleway

Sådan bruger du Scaleway Generative APIs med OpenCode:

Gå til Scaleway Console IAM indstillinger for at generere en ny API-nøgle.
Kør kommandoen /connect og søg efter Scaleway.
```
/connect
```
Indtast Scaleway API-nøglen.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model som devstral-2-123b-instruct-2512 eller gpt-oss-120b.
```
/models
```

Together AI

Gå til Together AI-konsollen, opret en konto og klik på Add Key.
Kør kommandoen /connect og søg efter Together AI.
```
/connect
```
Indtast Together AI API-nøglen.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model som Kimi K2 Instruct.
```
/models
```

Venice AI

Gå til Venice AI-konsollen, opret en konto og generer en API-nøgle.
Kør kommandoen /connect og søg efter Venice AI.
```
/connect
```
Indtast Venice AI API-nøglen.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model som Llama 3.3 70B.
```
/models
```

Vercel AI Gateway

Vercel AI Gateway lader dig få adgang til modeller fra OpenAI, Anthropic, Google, xAI og mere gennem et samlet endpoint. Modeller tilbydes til listepris uden påslag.

Gå til Vercel dashboard, naviger til fanen AI Gateway, og klik på API Keys for at oprette en ny API-nøgle.
Kør kommandoen /connect og søg efter Vercel AI Gateway.
```
/connect
```
Indtast Vercel AI Gateway API-nøgle.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model.
```
/models
```

Du kan også tilpasse modeller gennem opencode-konfigurationen. Her er et eksempel på specificering af udbyder-rutingsrækkefø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`	Begræns til specifikke udbydere
`zeroDataRetention`	Brug kun udbydere med nul retningslinjer for datalagring

xAI

Gå til xAI-konsollen, opret en konto og generer en API-nøgle.
Kør kommandoen /connect og søg efter xAI.
```
/connect
```
Indtast xAI API-nøglen.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model som Grok Beta.
```
/models
```

Z.AI

Gå til Z.AI API-konsollen, opret en konto og klik på Create new API Key.
Kør kommandoen /connect og søg efter Z.AI.
```
/connect
```
Hvis du abonnerer på GLM Coding Plan, vælg Z.AI Coding Plan.
Indtast Z.AI API-nøglen.
```
┌ API key
│
│
└ enter
```
Kør kommandoen /models for at vælge en model som GLM-4.7.
```
/models
```

ZenMux

Gå til ZenMux-dashboardet, klik på Create API Key, og kopier nøglen.
Kør kommandoen /connect og søg efter ZenMux.
```
/connect
```
Indtast API-nøglen for udbyderen.
```
┌ API key
│
│
└ enter
```
Mange ZenMux-modeller er forudindlæst som standard, kør kommandoen /models for at vælge den du ønsker.
```
/models
```
Du kan også tilføje flere modeller gennem opencode-konfigurationen.
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "zenmux": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}
```

Brugerdefineret udbyder

Sådan tilføjer du en OpenAI-kompatibel udbyder som ikke er opført i /connect-kommandoen:

Kør kommandoen /connect og rul ned til Other.

$ /connect

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

Indtast et unikt ID for udbyderen.
Terminal window
```
$ /connect

┌  Add credential
│
◇  Enter provider id
│  myprovider
└
```
Vælg et mindeværdigt ID, du vil bruge dette i din konfigurationsfil.

Indtast API-nøglen for udbyderen.

$ /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 projektkataloget:

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

npm: AI SDK pakke at bruge, @ai-sdk/openai-compatible for OpenAI-kompatible udbydere
name: Visningsnavn i UI.
models: Tilgængelige modeller.
options.baseURL: API endpoint URL.
options.apiKey: Angiv API-nøglen hvis du ikke bruger auth.
options.headers: Angiv egendefinerede headers.

Mere om de avancerede muligheder i eksemplet nedenfor.

Kør kommandoen /models og din egendefinerede udbyder og modeller vil vises i udvalgslisten.

Eksempel

Her er et eksempel på indstilling af mulighederne apiKey, headers og model 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
          }
        }
      }
    }
  }
}

Konfigurationsdetaljer:

apiKey: Angiv med env variabel syntaks, læs mere.
headers: Egendefinerede headers sendt med hver anmodning.
limit.context: Maksimalt input-tokens som modellen accepterer.
limit.output: Maksimalt antal tokens modellen kan generere.

limit-felterne lader OpenCode forstå hvor meget kontekst du har tilbage. Standardudbydere henter disse automatisk fra models.dev.

Fejlfinding

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

Tjek godkendelsesopsætningen: Kør opencode auth list for at se om legitimationsoplysningerne for udbyderen er tilføjet til din konfiguration.

Dette gælder ikke udbydere som Amazon Bedrock, som er afhængige af miljøvariabler for godkendelse.
For tilpassede udbydere, tjek opencode-konfigurationen og:
- Sørg for at udbyderens ID som bruges i /connect-kommandoen matcher ID i opencode-konfigurationen.
- Den rigtige npm-pakke bruges for udbyderen. Brug for eksempel @ai-sdk/cerebras for Cerebras. Og for alle andre OpenAI-kompatible udbydere, brug @ai-sdk/openai-compatible.
- Kontroller at korrekt API-endpoint er brugt i options.baseURL-feltet.