Providers

Korzystanie z dowolnego dostawcy LLM w opencode.

opencode używa AI SDK i Models.dev do obsługi ponad 75 dostawców LLM i obsługuje uruchamianie modeli lokalnych.

Aby dodać dostawcę należy:

Dodaj klucze API dla dostawcy za pomocą komendy /connect.
Skonfiguruj dostawcę w konfiguracji opencode.

Credentials

Po dodaniu kluczy API dostawcy za pomocą polecenia /connect są one przechowywane w ~/.local/share/opencode/auth.json.

Config

Możesz dostosować dostawców za pomocą sekcji provider w swoim opencode config.

Base URL

Możesz dostosować podstawowy adres URL dla dowolnego dostawcy, ustawiając opcję baseURL. Jest to przydatne podczas korzystania z usług proxy lub niestandardowych punktów końcowych.

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

OpenCode Zen

OpenCode Zen to lista modeli dostarczonych przez zespół opencode, które zostały przetestowane i zweryfikowane, aby dobrze współpracować z opencode. Dowiedz się więcej.

Uruchom polecenie /connect w TUI, wybierz opencode i przejdź do opencode.ai/auth.
```
/connect
```
Zaloguj się, dodaj szczegóły rozliczeniowe i skopiuj klucz API.
Wklej swój klucz API.
```
┌ API key
│
│
└ enter
```
Uruchom /models w TUI, aby zobaczyć listę zalecanych przez nas modeli.
```
/models
```

Działa jak każdy inny dostawca w opencode i jest całkowicie opcjonalny w użyciu.

Directory

Przyjrzyjmy się szczegółowo niektórym dostawcom. Jeśli chcesz dodać dostawcę do listę, możesz otworzyć PR.

302.AI

Przejdź do konsoli 302.AI, utwórz konto i wygeneruj klucz API.
Uruchom komendę /connect i wyszukaj 302.AI.
```
/connect
```
Wpisz swój klucz API 302.AI.
```
┌ API key
│
│
└ enter
```
Uruchom komendę /models, aby wybrać model.
```
/models
```

Amazon Bedrock

Aby używać Amazon Bedrock z opencode:

Przejdź do Katalogu modeli w konsoli Amazon Bedrock i poproś dostęp do wybranych modeli.

Musisz mieć dostęp do żądanego modelu w Amazon Bedrock.
Skonfiguruj uwierzytelnianie przy użyciu jednej z następujących metod:

Zmienne środowiskowe (Szybki start)

Ustaw jedną z tych zmiennych środowiskowych podczas uruchamiania opencode:
Okno terminala
```
# 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
```
Lub dodaj je do swojego profilu bash:
~/.bash_profile
```
export AWS_PROFILE=my-dev-profile
export AWS_REGION=us-east-1
```
Plik konfiguracyjny (zalecane)

W przypadku konfiguracji specyficznej dla projektu lub trwałej użyj opencode.json:
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "amazon-bedrock": {
      "options": {
        "region": "us-east-1",
        "profile": "my-aws-profile"
      }
    }
  }
}
```
Dostępne opcje:
- region - region AWS (np. us-east-1, eu-west-1)
- profile - profil nazwany AWS z ~/.aws/credentials
- endpoint — niestandardowy adres URL punktu końcowego dla punktów końcowych VPC (alias dla ogólnej opcji baseURL)
Opcje z pliku konfiguracyjnego mają pierwszeństwo przed zmiennymi środowiskowymi.

Zaawansowane: endpointy VPC

Jeśli używasz punktów końcowych VPC dla 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"
      }
    }
  }
}
```
Opcja endpoint jest aliasem ogólnej opcji baseURL, używając terminologii specyficznej dla AWS. Jeśli określono zarówno endpoint, jak i baseURL, pierwszeństwo ma endpoint.

Metody uwierzytelniania
- AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY: Utwórz użytkownika IAM i wygeneruj klucze dostępu w konsoli AWS
- AWS_PROFILE: Użyj nazwanych profili z ~/.aws/credentials. Najpierw skonfiguruj za pomocą aws configure --profile my-profile lub aws sso login
- AWS_BEARER_TOKEN_BEDROCK: Wygeneruj długoterminowe klucze API z konsoli Amazon Bedrock
- AWS_WEB_IDENTITY_TOKEN_FILE / AWS_ROLE_ARN: Dla EKS IRSA (Role IAM dla kont usług) lub innych środowisk Kubernetes z federacją OIDC. Te zmienne środowiskowe są automatycznie wstrzykiwane przez Kubernetes podczas korzystania z adnotacji konta usługi.
Kolejność uwierzytelniania

Amazon Bedrock wykorzystuje następujący priorytet uwierzytelniania:
1. Token nośnika - zmienna środowiskowa AWS_BEARER_TOKEN_BEDROCK lub token z komendy /connect
2. AWS Credential Chain - Profile, access keys, shared credentials, IAM roles, Web Identity Tokens (EKS IRSA), instance metadata
Gdy ustawisz bearer token (przez /connect lub AWS_BEARER_TOKEN_BEDROCK), ma on pierwszeństwo nad wszystkimi metodami poświadczeń AWS, w tym profilami.
Uruchom komendę /models, aby wybrać żądany model.
```
/models
```

W przypadku niestandardowych profili wnioskowania użyj nazwy modelu i dostawcy w kluczu i ustaw właściwość id na wartość arn. Zapewnia to prawidłowe buforowanie:

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

Po zarejestrowaniu się uruchom komendę /connect i wybierz opcję Anthropic.
```
/connect
```
Tutaj możesz wybrać opcję Claude Pro/Max, co spowoduje otwarcie przeglądarki i poproś o uwierzytelnienie.
```
┌ Select auth method
│
│ Claude Pro/Max
│ Create an API Key
│ Manually enter API Key
└
```
Teraz wszystkie modele antropiczne powinny być dostępne po użyciu polecenia /models.
```
/models
```

Korzystanie z subskrypcji Claude Pro/Max w opencode nie jest oficjalnie obsługiwane przez Anthropic.

Możesz także wybrać opcję Utwórz klucz API, jeśli nie masz subskrypcji Pro/Max. Otworzy się także Twoja przeglądarka i poprosi Cię o zalogowanie się do Anthropic i poda kod, który możesz wkleić w terminalu.

Lub jeśli masz już klucz API, możesz wybrać Wprowadź klucz API ręcznie i wkleić go w terminalu.

Azure OpenAI

Przejdź do Azure portal i utwórz zasób Azure OpenAI. Będziesz potrzebować:
- Nazwa zasobu: staje się częścią punktu końcowego API (https://RESOURCE_NAME.openai.azure.com/)
- Klucz API: KEY 1 lub KEY 2 z Twojego zasobu
Przejdź do Azure AI Foundry i wdróż model.

Aby kod opencode działał poprawnie, nazwa wdrożenia musi być zgodna z nazwą modelu.
Uruchom polecenie /connect i wyszukaj Azure.
```
/connect
```
Wpisz swój klucz API.
```
┌ API key
│
│
└ enter
```
Ustaw nazwę zasobu jako zmienną środowiskową:
Okno terminala
```
AZURE_RESOURCE_NAME=XXX opencode
```
Lub dodaj go do swojego profilu bash:
~/.bash_profile
```
export AZURE_RESOURCE_NAME=XXX
```
Uruchom komendę /models, aby wybrać wdrożony model.
```
/models
```

Azure Cognitive Services

Przejdź do Azure portal i utwórz zasób Azure OpenAI. Będziesz potrzebować:
- Nazwa zasobu: staje się częścią punktu końcowego API (https://AZURE_COGNITIVE_SERVICES_RESOURCE_NAME.cognitiveservices.azure.com/)
- Klucz API: KEY 1 lub KEY 2 z Twojego zasobu
Przejdź do Azure AI Foundry i wdróż model.

Aby kod opencode działał poprawnie, nazwa wdrożenia musi być zgodna z nazwą modelu.
Uruchom polecenie /connect i wyszukaj Azure Cognitive Services.
```
/connect
```
Wpisz swój klucz API.
```
┌ API key
│
│
└ enter
```
Ustaw nazwę zasobu jako zmienną środowiskową:
Okno terminala
```
AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
```
Lub dodaj go do swojego profilu bash:
~/.bash_profile
```
export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX
```
Uruchom komendę /models, aby wybrać wdrożony model.
```
/models
```

Baseten

Udaj się do Baseten, utwórz konto i wygeneruj klucz API.
Uruchom komendę /connect i wyszukaj Baseten.
```
/connect
```
Wprowadź swój klucz API Baseten.
```
┌ API key
│
│
└ enter
```
Uruchom komendę /models, aby wybrać model.
```
/models
```

Cerebras

Przejdź do konsoli Cerebras, utwórz konto i wygeneruj klucz API.
Uruchom komendę /connect i wyszukaj Cerebras.
```
/connect
```
Wprowadź swój klucz API Cerebras.
```
┌ API key
│
│
└ enter
```
Uruchom polecenie /models, aby wybrać model taki jak Qwen 3 Coder 480B.
```
/models
```

Cloudflare AI Gateway

Cloudflare AI Gateway umożliwia dostęp do modeli z OpenAI, Anthropic, Workers AI i innych za pośrednictwem ujednoliconego punktu końcowego. Dzięki Ujednoliconemu rozliczeniu nie potrzebujesz oddzielnych kluczy API dla każdego dostawcy.

Przejdź do panelu Cloudflare, przejdź do AI > AI Gateway i utwórz nową bramę.

Ustaw identyfikator konta i identyfikator bramy jako zmienne środowiskowe.

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

Uruchom polecenie /connect i wyszukaj Cloudflare AI Gateway.
```
/connect
```
Wprowadź swój token API Cloudflare.
```
┌ API key
│
│
└ enter
```
Or set it as an environment variable.
~/.bash_profile
```
export CLOUDFLARE_API_TOKEN=your-api-token
```

Uruchom komendę /models, aby wybrać model.

/models

Możesz także dodawać modele za pomocą konfiguracji opencode.

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

Cortecs

Przejdź do konsoli Cortecs, utwórz konto i wygeneruj klucz API.
Uruchom komendę /connect i wyszukaj Cortecs.
```
/connect
```
Wprowadź klucz API Cortecs.
```
┌ API key
│
│
└ enter
```
Uruchom polecenie /models, aby wybrać model taki jak Kimi K2 Instruct.
```
/models
```

DeepSeek

Przejdź do konsoli DeepSeek, utwórz konto i kliknij Utwórz nowy klucz API.
Uruchom polecenie /connect i wyszukaj DeepSeek.
```
/connect
```
Wprowadź klucz API DeepSeek.
```
┌ API key
│
│
└ enter
```
Uruchom polecenie /models, aby wybrać model DeepSeek, np. DeepSeek Reasoner.
```
/models
```

Deep Infra

Przejdź do panelu Deep Infra, utwórz konto i wygeneruj klucz API.
Uruchom komendę /connect i wyszukaj Deep Infra.
```
/connect
```
Wprowadź swój klucz API Deep Infra.
```
┌ API key
│
│
└ enter
```
Uruchom komendę /models, aby wybrać model.
```
/models
```

Firmware

Przejdź do Firmware dashboard, utwórz konto i wygeneruj klucz API.
Uruchom polecenie /connect i wyszukaj Firmware.
```
/connect
```
Wprowadź klucz API Firmware.
```
┌ API key
│
│
└ enter
```
Uruchom komendę /models, aby wybrać model.
```
/models
```

Fireworks AI

Przejdź do konsoli Fireworks AI, utwórz konto i kliknij Utwórz klucz API.
Uruchom polecenie /connect i wyszukaj Fireworks AI.
```
/connect
```
Wprowadź klucz API programu Fireworks AI.
```
┌ API key
│
│
└ enter
```
Uruchom polecenie /models, aby wybrać model taki jak Kimi K2 Instruct.
```
/models
```

GitLab Duo

GitLab Duo zapewnia czat agentowy oparty na sztucznej inteligencji z natywnymi możliwościami wywoływania narzędzi za pośrednictwem Anthropic proxy GitLab.

Uruchom komendę /connect i wybierz GitLab.
```
/connect
```
Wybierz metodę uwierzytelniania:
```
┌ Select auth method
│
│ OAuth (Recommended)
│ Personal Access Token
└
```
Using OAuth (Recommended)

Wybierz OAuth, a Twoja przeglądarka otworzy się w celu autoryzacji.

Using Personal Access Token
1. Przejdź do Ustawienia użytkownika GitLab > Tokeny dostępu
2. Click Add new token
3. Name: OpenCode, Scopes: api
4. Skopiuj token (zaczyna się od glpat-)
5. Wpisz go w terminalu
Uruchom komendę /models, aby zobaczyć dostępne modele.
```
/models
```
Dostępne są trzy modele oparte na Claude:
- duo-chat-haiku-4-5 (Domyślnie) - Szybkie odpowiedzi dla szybkich zadań
- duo-chat-sonnet-4-5 - Zrównoważona wydajność dla większości przepływów pracy
- duo-chat-opus-4-5 - Najbardziej zdolny do złożonej analizy

Self-Hosted GitLab

opencode używa małego modelu do niektórych zadań AI, takich jak generowanie tytułu sesji. Domyślnie jest skonfigurowany do używania gpt-5-nano, hostowanego przez Zen. Aby zablokować opencode aby używać tylko własnej instancji hostowanej przez GitLab, dodaj następujące elementy do pliku opencode.json plik. Zalecane jest również wyłączenie udostępniania sesji.

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

W przypadku samodzielnie hostowanych instancji GitLab:

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

Jeśli w Twojej instancji działa niestandardowa brama AI:

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

Lub dodaj do swojego profilu bash:

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

OAuth dla instancji hostowanych samodzielnie

Aby Oauth mógł działać w przypadku Twojej instancji hostowanej samodzielnie, musisz utworzyć nową aplikację (Ustawienia → Aplikacje) z Adres URL wywołania zwrotnego http://127.0.0.1:8080/callback i następujące zakresy:

api (Uzyskaj dostęp do API w swoim imieniu)
read_user (Przeczytaj swoje dane osobowe)
read_repository (umożliwia dostęp do repozytorium tylko do odczytu)

Następnie ustaw ID aplikacji jako zmienną środowiskową:

export GITLAB_OAUTH_CLIENT_ID=your_application_id_here

Więcej informacji znajdziesz na stronie opencode-gitlab-auth.

Configuration

Customize through 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 Tools (Optional, but highly recommended)

To access GitLab tools (merge requests, issues, pipelines, CI/CD, etc.):

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

Ta wtyczka zapewnia kompleksowe możliwości zarządzania repozytorium GitLab, w tym recenzje MR, śledzenie problemów, monitorowanie rurociągów i inne.

GitHub Copilot

Aby korzystać z subskrypcji GitHub Copilot z kodem opencode:

Uruchom komendę /connect i wyszukaj GitHub Copilot.
```
/connect
```

Przejdź do github.com/login/device i wpisz kod.

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

Teraz uruchom polecenie /models, aby wybrać żądany model.
```
/models
```

Google Vertex AI

Aby używać Google Vertex AI z opencode:

Przejdź do Model Garden w Google Cloud Console i sprawdź modele dostępne w Twoim regionie.

Musisz mieć projekt Google Cloud z włączonym interfejsem API Vertex AI.
Ustaw wymagane zmienne środowiskowe:
- GOOGLE_CLOUD_PROJECT: identyfikator Twojego projektu Google Cloud
- VERTEX_LOCATION (opcjonalnie): region Vertex AI (domyślnie global)
- Authentication (choose one):
  - GOOGLE_APPLICATION_CREDENTIALS: Ścieżka do pliku klucza JSON konta usługi
  - Uwierzytelnij się za pomocą interfejsu CLI gcloud: gcloud auth application-default login
Set them while running opencode.
Okno terminala
```
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id opencode
```
Lub dodaj je do swojego profilu bash.
~/.bash_profile
```
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
export GOOGLE_CLOUD_PROJECT=your-project-id
export VERTEX_LOCATION=global
```

Uruchom komendę /models, aby wybrać żądany model.
```
/models
```

Groq

Przejdź do konsoli Groq, kliknij Utwórz klucz API i skopiuj klucz.
Uruchom komendę /connect i wyszukaj Groq.
```
/connect
```
Wprowadź klucz API dla dostawcy.
```
┌ API key
│
│
└ enter
```
Uruchom polecenie /models, aby wybrać żądany.
```
/models
```

Hugging Face

Inference Providers Hugging Face zapewniają dostęp do otwartych modeli obsługiwanych przez ponad 17 dostawców.

Przejdź do ustawień Hugging Face, aby utworzyć token z uprawnieniami do wykonywania połączeń z dostawcami wnioskowania.
Uruchom komendę /connect i wyszukaj Hugging Face.
```
/connect
```
Wprowadź swój token Hugging Face.
```
┌ API key
│
│
└ enter
```
Uruchom polecenie /models, aby wybrać model taki jak Kimi-K2-Instruct lub GLM-4.6.
```
/models
```

Helicone

Helicone to platforma obserwowalności LLM, która zapewnia rejestrowanie, monitorowanie i analizy dla aplikacji AI. Helicone AI Gateway automatycznie kieruje Twoje żądania do odpowiedniego dostawcy w oparciu o model.

Udaj się do Helicone, utwórz konto i wygeneruj klucz API ze swojego panelu.
Uruchom komendę /connect i wyszukaj Helicone.
```
/connect
```
Wprowadź swój klucz API Helicone.
```
┌ API key
│
│
└ enter
```
Uruchom komendę /models, aby wybrać model.
```
/models
```

Więcej dostawców i zaawansowanych funkcji, takich jak buforowanie i ograniczanie szybkości, znajdziesz w dokumentacji Helicone.

Opcjonalna konfiguracja

Jeśli zobaczysz funkcję lub model firmy Helicone, która nie jest konfigurowana automatycznie za pomocą opencode, zawsze możesz ją skonfigurować samodzielnie.

Oto Katalog modeli Helicone, będziesz go potrzebować, aby pobrać identyfikatory modeli, które chcesz dodać.

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

Niestandardowe nagłówki

Helicone obsługuje niestandardowe nagłówki dla funkcji takich jak buforowanie, śledzenie użytkowników i zarządzanie sesjami. Dodaj je do konfiguracji dostawcy za pomocą 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",
        },
      },
    },
  },
}

Śledzenie sesji

Funkcja Sesje firmy Helicone umożliwia grupowanie powiązanych żądań LLM. Użyj wtyczki opencode-helicone-session, aby automatycznie rejestrować każdą konwersację opencode jako sesję w Helicone.

npm install -g opencode-helicone-session

Dodaj go do swojej konfiguracji.

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

Wtyczka wstawia nagłówki Helicone-Session-Id i Helicone-Session-Name do Twoich żądań. Na stronie Sesje Helicone każda konwersacja opencode będzie wymieniona jako osobna sesja.

Najczęstsze nagłówki Helicone

Header	Description
`Helicone-Cache-Enabled`	Enable response caching (`true`/`false`)
`Helicone-User-Id`	Track metrics by user
`Helicone-Property-[Name]`	Add custom properties (e.g., `Helicone-Property-Environment`)
`Helicone-Prompt-Id`	Powiąż żądania z wersjami podpowiedzi

Zobacz Katalog nagłówków Helicone, aby poznać wszystkie dostępne nagłówki.

llama.cpp

Możesz skonfigurować opencode tak, aby korzystał z modeli lokalnych, za pomocą narzędzia llama-server llama.cpp

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

W tym przykładzie:

llama.cpp to niestandardowy identyfikator dostawcy. Może to być dowolny ciąg znaków.
npm określa pakiet, który ma być używany dla tego dostawcy. Tutaj @ai-sdk/openai-compatible jest używany dla dowolnego API zgodnego z OpenAI.
name to nazwa wyświetlana dostawcy w interfejsie użytkownika.
options.baseURL jest punktem końcowym serwera lokalnego.
models to mapa identyfikatorów modeli do ich konfiguracji. Nazwa modelu zostanie wyświetlona na liście wyboru modelu.

IO.NET

IO.NET oferuje 17 modeli zoptymalizowanych pod kątem różnych zastosowań:

Przejdź do konsoli IO.NET, utwórz konto i wygeneruj klucz API.
Uruchom komendę /connect i wyszukaj IO.NET.
```
/connect
```
Wprowadź swój klucz API IO.NET.
```
┌ API key
│
│
└ enter
```
Uruchom komendę /models, aby wybrać model.
```
/models
```

LM Studio

Możesz skonfigurować opencode tak, aby korzystał z modeli lokalnych poprzez 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)"
        }
      }
    }
  }
}

W tym przykładzie:

lmstudio to niestandardowy identyfikator dostawcy. Może to być dowolny ciąg znaków.
npm określa pakiet, który ma być używany dla tego dostawcy. Tutaj @ai-sdk/openai-compatible jest używany dla dowolnego API zgodnego z OpenAI.
name to nazwa wyświetlana dostawcy w interfejsie użytkownika.
options.baseURL jest punktem końcowym serwera lokalnego.
models to mapa identyfikatorów modeli do ich konfiguracji. Nazwa modelu zostanie wyświetlona na liście wyboru modelu.

Moonshot AI

Aby użyć Kimi K2 z Moonshot AI:

Przejdź do konsoli Moonshot AI, utwórz konto i kliknij Utwórz klucz API.
Uruchom polecenie /connect i wyszukaj Moonshot AI.
```
/connect
```
Wprowadź klucz API Moonshot.
```
┌ API key
│
│
└ enter
```
Uruchom komendę /models, aby wybrać Kimi K2.
```
/models
```

MiniMax

Przejdź do konsoli API MiniMax, utwórz konto i wygeneruj klucz API.
Uruchom komendę /connect i wyszukaj MiniMax.
```
/connect
```
Wprowadź swój klucz API MiniMax.
```
┌ API key
│
│
└ enter
```
Uruchom komendę /models, aby wybrać model taki jak M2.1.
```
/models
```

Nebius Token Factory

Przejdź do konsoli Nebius Token Factory, utwórz konto i kliknij Dodaj klucz.
Uruchom komendę /connect i wyszukaj Nebius Token Factory.
```
/connect
```
Wprowadź klucz API Nebius Token Factory.
```
┌ API key
│
│
└ enter
```
Uruchom polecenie /models, aby wybrać model taki jak Kimi K2 Instruct.
```
/models
```

Ollama

Możesz skonfigurować opencode tak, aby korzystał z modeli lokalnych poprzez Ollamę.

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

W tym przykładzie:

ollama to niestandardowy identyfikator dostawcy. Może to być dowolny ciąg znaków.
npm określa pakiet, który ma być używany dla tego dostawcy. Tutaj @ai-sdk/openai-compatible jest używany dla dowolnego API zgodnego z OpenAI.
name to nazwa wyświetlana dostawcy w interfejsie użytkownika.
options.baseURL jest punktem końcowym serwera lokalnego.
models to mapa identyfikatorów modeli do ich konfiguracji. Nazwa modelu zostanie wyświetlona na liście wyboru modelu.

Ollama Cloud

Aby korzystać z Ollama Cloud z opencode:

Udaj się do https://ollama.com/ i zaloguj się lub utwórz konto.
Przejdź do Ustawienia > Klucze i kliknij Dodaj klucz API, aby wygenerować nowy klucz API.
Skopiuj klucz API do użycia w opencode.
Uruchom polecenie /connect i wyszukaj Ollama Cloud.
```
/connect
```
Wprowadź swój klucz API Ollama Cloud.
```
┌ API key
│
│
└ enter
```
Ważne: Przed użyciem modeli chmurowych w opencode musisz pobrać informacje o modelu lokalnie:
Okno terminala
```
ollama pull gpt-oss:20b-cloud
```
Uruchom polecenie /models, aby wybrać model Ollama Cloud.
```
/models
```

OpenAI

Zalecamy zarejestrowanie się w ChatGPT Plus lub Pro.

Po zarejestrowaniu się uruchom komendę /connect i wybierz OpenAI.
```
/connect
```
Tutaj możesz wybrać opcję ChatGPT Plus/Pro, co spowoduje otwarcie przeglądarki i poproś o uwierzytelnienie.
```
┌ Select auth method
│
│ ChatGPT Plus/Pro
│ Manually enter API Key
└
```
Teraz wszystkie modele OpenAI powinny być dostępne po użyciu polecenia /models.
```
/models
```

Użycie kluczy API

Jeśli posiadasz już klucz API, możesz wybrać opcję Wprowadź klucz API ręcznie i wkleić go w terminalu.

OpenCode Zen

OpenCode Zen to lista przetestowanych i zweryfikowanych modeli udostępniona przez zespół opencode. Dowiedz się więcej.

Zaloguj się do OpenCode Zen i kliknij Utwórz klucz API.
Uruchom polecenie /connect i wyszukaj OpenCode Zen.
```
/connect
```
Wprowadź klucz API opencode.
```
┌ API key
│
│
└ enter
```
Uruchom polecenie /models, aby wybrać model taki jak Qwen 3 Coder 480B.
```
/models
```

OpenRouter

Przejdź do panelu OpenRouter, kliknij Utwórz klucz API i skopiuj klucz.
Uruchom komendę /connect i wyszukaj OpenRouter.
```
/connect
```
Wprowadź klucz API dla dostawcy.
```
┌ API key
│
│
└ enter
```
Wiele modeli OpenRouter jest domyślnie załadowanych fabrycznie. Uruchom komendę /models, aby wybrać ten, który chcesz.
```
/models
```
Możesz także dodać dodatkowe modele za pomocą konfiguracji opencode.
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openrouter": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}
```

Możesz je także dostosować za pomocą konfiguracji opencode. Oto przykład określenia dostawcy

{
  "$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 zapewnia dostęp do ponad 40 modeli z OpenAI, Anthropic, Google, Amazon, Meta, Mistral i AI21 za pośrednictwem ujednoliconej platformy.

Przejdź do SAP BTP Cockpit, przejdź do instancji usługi SAP AI Core i utwórz klucz usługi.

Klucz usługi to obiekt JSON zawierający clientid, clientsecret, url i serviceurls.AI_API_URL. Instancję AI Core znajdziesz w sekcji Usługi > Instancje i subskrypcje w Kokpicie BTP.
Uruchom polecenie /connect i wyszukaj SAP AI Core.
```
/connect
```

Wpisz swój klucz usługi JSON.

┌ Service key
│
│
└ enter

Lub ustaw zmienną środowiskową AICORE_SERVICE_KEY:

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

Lub dodaj go do swojego profilu bash:

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

Opcjonalnie ustaw identyfikator wdrożenia i grupę zasobów:
Okno terminala
```
AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode
```
Te ustawienia są opcjonalne i należy je skonfigurować zgodnie z konfiguracją SAP AI Core.
Uruchom polecenie /models, aby wybrać spośród ponad 40 dostępnych modeli.
```
/models
```

OVHcloud AI Endpoints

Przejdź do panelu OVHcloud. Przejdź do sekcji Public Cloud, AI & Machine Learning > AI Endpoints i na karcie API Keys kliknij Utwórz nowy klucz API.
Uruchom polecenie /connect i wyszukaj Punkty końcowe AI OVHcloud.
```
/connect
```
Wpisz klucz API punktów końcowych AI OVHcloud.
```
┌ API key
│
│
└ enter
```
Uruchom polecenie /models, aby wybrać model taki jak gpt-oss-120b.
```
/models
```

Scaleway

Aby używać generatywnych interfejsów API Scaleway z opencode:

Przejdź do Ustawień uprawnień konsoli Scaleway, aby wygenerować nowy klucz API.
Uruchom komendę /connect i wyszukaj Scaleway.
```
/connect
```
Wprowadź swój klucz API Scaleway.
```
┌ API key
│
│
└ enter
```
Uruchom komendę /models, aby wybrać model taki jak devstral-2-123b-instruct-2512 lub gpt-oss-120b.
```
/models
```

Together AI

Przejdź do konsoli Together AI, utwórz konto i kliknij Dodaj klucz.
Uruchom komendę /connect i wyszukaj Together AI.
```
/connect
```
Wprowadź klucz API Together AI.
```
┌ API key
│
│
└ enter
```
Uruchom polecenie /models, aby wybrać model taki jak Kimi K2 Instruct.
```
/models
```

Venice AI

Przejdź do konsoli Venice AI, utwórz konto i wygeneruj klucz API.
Uruchom polecenie /connect i wyszukaj Venice AI.
```
/connect
```
Wprowadź klucz API Venice AI.
```
┌ API key
│
│
└ enter
```
Uruchom polecenie /models, aby wybrać model taki jak Llama 3.3 70B.
```
/models
```

Vercel AI Gateway

Vercel AI Gateway umożliwia dostęp do modeli z OpenAI, Anthropic, Google, xAI i innych za pośrednictwem ujednoliconego punktu końcowego. Modele oferowane są po cenie katalogowej bez marży.

Przejdź do panelu Vercel, przejdź do karty AI Gateway i kliknij Klucze API, aby utworzyć nowy klucz API.
Uruchom polecenie /connect i wyszukaj Vercel AI Gateway.
```
/connect
```
Wprowadź klucz API Vercel AI Gateway.
```
┌ API key
│
│
└ enter
```
Uruchom komendę /models, aby wybrać model.
```
/models
```

Możesz także dostosować modele za pomocą konfiguracji opencode. Oto przykład określenia kolejności routingu dostawcy.

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "vercel": {
      "models": {
        "anthropic/claude-sonnet-4": {
          "options": {
            "order": ["anthropic", "vertex"]
          }
        }
      }
    }
  }
}

Przydatne opcje routingu:

Opcja	Opis
`order`	Sekwencja dostawcy do wypróbowania
`only`	Ograniczenie do wskazanych dostawców
`zeroDataRetention`	Korzystaj wyłącznie z dostawców, którzy nie mają zasad przechowywania danych

xAI

Przejdź do konsoli xAI, utwórz konto i wygeneruj klucz API.
Uruchom komendę /connect i wyszukaj xAI.
```
/connect
```
Wprowadź swój klucz API xAI.
```
┌ API key
│
│
└ enter
```
Uruchom polecenie /models, aby wybrać model taki jak Grok Beta.
```
/models
```

Z.AI

Przejdź do konsoli API Z.AI, utwórz konto i kliknij Utwórz nowy klucz API.
Uruchom komendę /connect i wyszukaj Z.AI.
```
/connect
```
Jeżeli jesteś abonentem Planu kodowania GLM, wybierz Plan kodowania Z.AI.
Wpisz swój klucz API Z.AI.
```
┌ API key
│
│
└ enter
```
Uruchom komendę /models, aby wybrać model taki jak GLM-4.7.
```
/models
```

ZenMux

Przejdź do panelu ZenMux, kliknij Utwórz klucz API i skopiuj klucz.
Uruchom polecenie /connect i wyszukaj ZenMux.
```
/connect
```
Wprowadź klucz API dla dostawcy.
```
┌ API key
│
│
└ enter
```
Wiele modeli ZenMux jest domyślnie załadowanych fabrycznie. Uruchom komendę /models, aby wybrać żądany model.
```
/models
```
Możesz także dodać dodatkowe modele za pomocą konfiguracji opencode.
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "zenmux": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}
```

Niestandardowy dostawca

Aby dodać dowolnego dostawcę kompatybilnego z OpenAI, którego nie ma na liście w poleceniu /connect:

Uruchom polecenie /connect i przewiń w dół do Inne.

$ /connect

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

Wprowadź unikalny identyfikator dostawcy.
Okno terminala
```
$ /connect

┌  Add credential
│
◇  Enter provider id
│  myprovider
└
```
Wybierz niezapomniany identyfikator, użyjesz go w swoim pliku konfiguracyjnym.

Wprowadź klucz API dla dostawcy.

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

Utwórz lub zaktualizuj plik opencode.json w katalogu projektu:
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"
        }
      }
    }
  }
}
```
Oto opcje konfiguracji:
- npm: pakiet AI SDK do użycia, @ai-sdk/openai-compatible dla dostawców kompatybilnych z OpenAI
- name: Nazwa wyświetlana w UI.
- modele: Dostępne modele.
- options.baseURL: URL endpointu API.
- options.apiKey: Opcjonalnie ustaw klucz API, jeśli nie używasz autoryzacji.
- options.headers: Opcjonalnie ustaw niestandardowe nagłówki.
Więcej o opcjach zaawansowanych w przykładzie poniżej.
Uruchom polecenie /models, a niestandardowy dostawca i modele pojawią się na liście wyboru.

Przykład

Oto przykład ustawienia opcji apiKey, headers i modelu 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
          }
        }
      }
    }
  }
}

Szczegóły konfiguracji:

apiKey: Ustaw przy użyciu składni zmiennej env, dowiedz się więcej.
nagłówki: niestandardowe nagłówki wysyłane z każdym żądaniem.
limit.context: Maksymalna liczba tokenów wejściowych akceptowanych przez model.
limit.output: Maksymalna liczba tokenów, które model może wygenerować.

Pola limit pozwalają opencode zrozumieć, ile kontekstu pozostało. Standardowi dostawcy pobierają je automatycznie z models.dev.

Troubleshooting

Jeśli masz problemy z konfiguracją dostawcy, sprawdź następujące elementy:

Sprawdź konfigurację uwierzytelniania: Uruchom opencode auth list, aby sprawdzić, czy poświadczenia dla dostawcy są dodawane do Twojej konfiguracji.

Nie dotyczy to dostawców takich jak Amazon Bedrock, którzy w procesie uwierzytelniania opierają się na zmiennych środowiskowych.
W przypadku dostawców niestandardowych sprawdź konfigurację opencode i:
- Upewnij się, że identyfikator dostawcy użyty w poleceniu /connect jest zgodny z identyfikatorem w konfiguracji opencode.
- Dla dostawcy używany jest właściwy pakiet npm. Na przykład użyj @ai-sdk/cerebras dla Cerebras. W przypadku wszystkich innych dostawców zgodnych z OpenAI użyj @ai-sdk/openai-compatible.
- Sprawdź, czy w polu options.baseURL użyto prawidłowego punktu końcowego API.