opencode / packages /web /src /content /docs /pl /providers.mdx

Add files using upload-large-folder tool

0dbc9de verified 13 days ago

48.8 kB

	---
	title: Dostawcy
	description: Korzystanie z dowolnego dostawcy LLM w opencode.
	---

	import config from "../../../../config.mjs"
	export const console = config.console

	opencode używa [AI SDK](https://ai-sdk.dev/) i [Models.dev](https://models.dev) do obsługi ponad 75 dostawców LLM i obsługuje uruchamianie modeli lokalnych.

	Aby dodać dostawcę należy:

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

	---

	### Credentials

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

	---

	### Konfiguracja

	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.

	```json title="opencode.json" {6}
	{
	"$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](/docs/zen).

	:::tip
	Jeśli jesteś nowy, zalecamy rozpoczęcie od OpenCode Zen.
	:::

	1. Uruchom polecenie `/connect` w TUI, wybierz `OpenCode Zen` i przejdź do [opencode.ai/auth](https://opencode.ai/zen).

	```txt
	/connect
	```

	2. Zaloguj się, dodaj szczegóły rozliczeniowe i skopiuj klucz API.

	3. Wklej swój klucz API.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom `/models` w TUI, aby zobaczyć listę zalecanych przez nas modeli.

	```txt
	/models
	```

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

	---

	## OpenCode Go

	OpenCode Go to tani plan subskrypcji, który zapewnia niezawodny dostęp do popularnych modeli open coding dostarczanych przez zespół opencode, które zostały przetestowane i zweryfikowane pod kątem dobrej współpracy z opencode.

	1. Uruchom polecenie `/connect` w TUI, wybierz `OpenCode Go` i przejdź do [opencode.ai/auth](https://opencode.ai/zen).

	```txt
	/connect
	```

	2. Zaloguj się, dodaj szczegóły rozliczeniowe i skopiuj klucz API.

	3. Wklej swój klucz API.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom `/models` w TUI, aby zobaczyć listę zalecanych przez nas modeli.

	```txt
	/models
	```

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

	---

	## Katalog

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

	:::note
	Nie widzisz tutaj dostawcy? Prześlij PR.
	:::

	---

	### 302.AI

	1. Przejdź do [konsoli 302.AI](https://302.ai/), utwórz konto i wygeneruj klucz API.

	2. Uruchom komendę `/connect` i wyszukaj 302.AI.

	```txt
	/connect
	```

	3. Wpisz swój klucz API 302.AI.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom komendę `/models`, aby wybrać model.

	```txt
	/models
	```

	---

	### Amazon Bedrock

	Aby używać Amazon Bedrock z opencode:

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

	:::tip
	Musisz mieć dostęp do żądanego modelu w Amazon Bedrock.
	:::

	2. Skonfiguruj uwierzytelnianie przy użyciu jednej z następujących metod:

	#### Zmienne środowiskowe (Szybki start)

	Ustaw jedną z tych zmiennych środowiskowych podczas uruchamiania opencode:

	```bash
	# Option 1: Using AWS access keys
	AWS_ACCESS_KEY_ID=XXX AWS_SECRET_ACCESS_KEY=YYY opencode

	# Option 2: Using named AWS profile
	AWS_PROFILE=my-profile opencode

	# Option 3: Using Bedrock bearer token
	AWS_BEARER_TOKEN_BEDROCK=XXX opencode
	```

	Lub dodaj je do swojego profilu bash:

	```bash title="~/.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`:

	```json title="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`)

	:::tip
	Opcje z pliku konfiguracyjnego mają pierwszeństwo przed zmiennymi środowiskowymi.
	:::

	#### Zaawansowane: Punkty końcowe VPC

	Jeśli używasz punktów końcowych VPC dla Bedrock:

	```json title="opencode.json"
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"amazon-bedrock": {
	"options": {
	"region": "us-east-1",
	"profile": "production",
	"endpoint": "https://bedrock-runtime.us-east-1.vpce-xxxxx.amazonaws.com"
	}
	}
	}
	}
	```

	:::note
	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

	:::note
	Gdy ustawisz bearer token (przez `/connect` lub `AWS_BEARER_TOKEN_BEDROCK`), ma on pierwszeństwo nad wszystkimi metodami poświadczeń AWS, w tym profilami.
	:::

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

	```txt
	/models
	```

	:::note
	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:

	```json title="opencode.json"
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"amazon-bedrock": {
	// ...
	"models": {
	"anthropic-claude-sonnet-4.5": {
	"id": "arn:aws:bedrock:us-east-1:xxx:application-inference-profile/yyy"
	}
	}
	}
	}
	}
	```

	:::

	---

	### Anthropic

	1. Po zarejestrowaniu się uruchom komendę `/connect` i wybierz opcję Anthropic.

	```txt
	/connect
	```

	2. Tutaj możesz wybrać opcję Claude Pro/Max, co spowoduje otwarcie przeglądarki
	i poproś o uwierzytelnienie.

	```txt
	┌ Select auth method
	│
	│ Claude Pro/Max
	│ Create an API Key
	│ Manually enter API Key
	└
	```

	3. Teraz wszystkie modele antropiczne powinny być dostępne po użyciu polecenia `/models`.

	```txt
	/models
	```

	:::info
	Korzystanie z subskrypcji Claude Pro/Max w opencode nie jest oficjalnie obsługiwane przez [Anthropic](https://anthropic.com).
	:::

	##### Użycie kluczy API

	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.

	---

	### Atomic Chat

	Możesz skonfigurować opencode do korzystania z modeli lokalnych przez [Atomic Chat](https://atomic.chat) — aplikację desktopową uruchamiającą lokalne LLM-y za serwerem API zgodnym z OpenAI (domyślny endpoint `http://127.0.0.1:1337/v1`).

	```json title="opencode.json" "atomic-chat" {5, 6, 8, 10-14}
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"atomic-chat": {
	"npm": "@ai-sdk/openai-compatible",
	"name": "Atomic Chat (local)",
	"options": {
	"baseURL": "http://127.0.0.1:1337/v1"
	},
	"models": {
	"<your-model-id>": {
	"name": "<your-model-name>"
	}
	}
	}
	}
	}
	```

	W tym przykładzie:

	- `atomic-chat` to niestandardowy identyfikator dostawcy. Może to być dowolny ciąg znaków.
	- `npm` określa pakiet używany dla tego dostawcy. Tutaj `@ai-sdk/openai-compatible` jest używany dla każdego API zgodnego z OpenAI.
	- `name` to nazwa wyświetlana dostawcy w interfejsie.
	- `options.baseURL` to endpoint serwera lokalnego. Zmień host i port, aby pasowały do twojej konfiguracji Atomic Chat.
	- `models` to mapa identyfikatorów modeli na ich nazwy wyświetlane. Każdy identyfikator musi odpowiadać `id` zwracanemu przez `GET /v1/models` — uruchom `curl http://127.0.0.1:1337/v1/models`, aby wyświetlić identyfikatory aktualnie załadowane w Atomic Chat.

	:::tip
	Jeśli wywołania narzędzi nie działają dobrze, wybierz załadowany model z dobrym wsparciem tool calling (na przykład wariant Qwen-Coder lub DeepSeek-Coder).
	:::

	---

	### Azure OpenAI

	:::note
	Jeśli napotkasz błędy „Przykro mi, ale nie mogę pomóc w tej prośbie”, spróbuj zmienić filtr zawartości z DefaultV2 na Default w zasobie platformy Azure.
	:::

	1. Przejdź do [Azure portal](https://portal.azure.com/) 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

	2. Przejdź do [Azure AI Foundry](https://ai.azure.com/) i wdróż model.

	:::note
	Aby kod opencode działał poprawnie, nazwa wdrożenia musi być zgodna z nazwą modelu.
	:::

	3. Uruchom polecenie `/connect` i wyszukaj Azure.

	```txt
	/connect
	```

	4. Wpisz swój klucz API.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	5. Ustaw nazwę zasobu jako zmienną środowiskową:

	```bash
	AZURE_RESOURCE_NAME=XXX opencode
	```

	Lub dodaj go do swojego profilu bash:

	```bash title="~/.bash_profile"
	export AZURE_RESOURCE_NAME=XXX
	```

	6. Uruchom komendę `/models`, aby wybrać wdrożony model.

	```txt
	/models
	```

	---

	### Azure Cognitive Services

	1. Przejdź do [Azure portal](https://portal.azure.com/) 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

	2. Przejdź do [Azure AI Foundry](https://ai.azure.com/) i wdróż model.

	:::note
	Aby kod opencode działał poprawnie, nazwa wdrożenia musi być zgodna z nazwą modelu.
	:::

	3. Uruchom polecenie `/connect` i wyszukaj Azure Cognitive Services.

	```txt
	/connect
	```

	4. Wpisz swój klucz API.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	5. Ustaw nazwę zasobu jako zmienną środowiskową:

	```bash
	AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
	```

	Lub dodaj go do swojego profilu bash:

	```bash title="~/.bash_profile"
	export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX
	```

	6. Uruchom komendę `/models`, aby wybrać wdrożony model.

	```txt
	/models
	```

	---

	### Baseten

	1. Udaj się do [Baseten](https://app.baseten.co/), utwórz konto i wygeneruj klucz API.

	2. Uruchom komendę `/connect` i wyszukaj Baseten.

	```txt
	/connect
	```

	3. Wprowadź swój klucz API Baseten.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom komendę `/models`, aby wybrać model.

	```txt
	/models
	```

	---

	### Cerebras

	1. Przejdź do [konsoli Cerebras](https://inference.cerebras.ai/), utwórz konto i wygeneruj klucz API.

	2. Uruchom komendę `/connect` i wyszukaj Cerebras.

	```txt
	/connect
	```

	3. Wprowadź swój klucz API Cerebras.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom polecenie `/models`, aby wybrać model taki jak _Qwen 3 Coder 480B_.

	```txt
	/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](https://developers.cloudflare.com/ai-gateway/features/unified-billing/) nie potrzebujesz oddzielnych kluczy API dla każdego dostawcy.

	1. Przejdź do [panelu Cloudflare](https://dash.cloudflare.com/), przejdź do AI > AI Gateway i utwórz nową bramę.

	2. Ustaw identyfikator konta i identyfikator bramy jako zmienne środowiskowe.

	```bash title="~/.bash_profile"
	export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
	export CLOUDFLARE_GATEWAY_ID=your-gateway-id
	```

	3. Uruchom polecenie `/connect` i wyszukaj Cloudflare AI Gateway.

	```txt
	/connect
	```

	4. Wprowadź swój token API Cloudflare.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	Lub ustaw go jako zmienną środowiskową.

	```bash title="~/.bash_profile"
	export CLOUDFLARE_API_TOKEN=your-api-token
	```

	5. Uruchom komendę `/models`, aby wybrać model.

	```txt
	/models
	```

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

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

	---

	### Cortecs

	1. Przejdź do [konsoli Cortecs](https://cortecs.ai/), utwórz konto i wygeneruj klucz API.

	2. Uruchom komendę `/connect` i wyszukaj Cortecs.

	```txt
	/connect
	```

	3. Wprowadź klucz API Cortecs.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom polecenie `/models`, aby wybrać model taki jak _Kimi K2 Instruct_.

	```txt
	/models
	```

	---

	### DeepSeek

	1. Przejdź do [konsoli DeepSeek](https://platform.deepseek.com/), utwórz konto i kliknij Utwórz nowy klucz API.

	2. Uruchom polecenie `/connect` i wyszukaj DeepSeek.

	```txt
	/connect
	```

	3. Wprowadź klucz API DeepSeek.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom polecenie `/models`, aby wybrać model DeepSeek, np. _DeepSeek V4 Pro_.

	```txt
	/models
	```

	---

	### Deep Infra

	1. Przejdź do [panelu Deep Infra](https://deepinfra.com/dash), utwórz konto i wygeneruj klucz API.

	2. Uruchom komendę `/connect` i wyszukaj Deep Infra.

	```txt
	/connect
	```

	3. Wprowadź swój klucz API Deep Infra.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom komendę `/models`, aby wybrać model.

	```txt
	/models
	```

	---

	### FrogBot

	1. Przejdź do [FrogBot dashboard](https://app.frogbot.ai/signup), utwórz konto i wygeneruj klucz API.

	2. Uruchom polecenie `/connect` i wyszukaj FrogBot.

	```txt
	/connect
	```

	3. Wprowadź klucz API FrogBot.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom komendę `/models`, aby wybrać model.

	```txt
	/models
	```

	---

	### Fireworks AI

	1. Przejdź do [konsoli Fireworks AI](https://app.fireworks.ai/), utwórz konto i kliknij Utwórz klucz API.

	2. Uruchom polecenie `/connect` i wyszukaj Fireworks AI.

	```txt
	/connect
	```

	3. Wprowadź klucz API programu Fireworks AI.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom polecenie `/models`, aby wybrać model taki jak _Kimi K2 Instruct_.

	```txt
	/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.

	1. Uruchom komendę `/connect` i wybierz GitLab.

	```txt
	/connect
	```

	2. Wybierz metodę uwierzytelniania:

	```txt
	┌ Select auth method
	│
	│ OAuth (Recommended)
	│ Personal Access Token
	└
	```

	#### Using OAuth (Recommended)

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

	#### Użycie osobistego tokenu dostępu
	1. Przejdź do [Ustawienia użytkownika GitLab > Tokeny dostępu](https://gitlab.com/-/user_settings/personal_access_tokens)
	2. Click Add new token
	3. Name: `OpenCode`, Scopes: `api`
	4. Skopiuj token (zaczyna się od `glpat-`)
	5. Wpisz go w terminalu

	3. Uruchom komendę `/models`, aby zobaczyć dostępne modele.

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

	:::note
	Jeśli nie chcesz, możesz także określić zmienną środowiskową „GITLAB_TOKEN”.
	to store token in opencode auth storage.
	:::

	##### Self-Hosted GitLab

	:::note[compliance note]
	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.

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

	:::

	W przypadku samodzielnie hostowanych instancji GitLab:

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

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

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

	Lub dodaj do swojego profilu bash:

	```bash title="~/.bash_profile"
	export GITLAB_INSTANCE_URL=https://gitlab.company.com
	export GITLAB_AI_GATEWAY_URL=https://ai-gateway.company.com
	export GITLAB_TOKEN=glpat-...
	```

	:::note
	Twój administrator GitLab musi włączyć następujące opcje:

	1. [Platforma Duo Agent](https://docs.gitlab.com/user/duo_agent_platform/turn_on_off/) dla użytkownika, grupy lub instancji
	2. Feature flags (via Rails console):
	- `agent_platform_claude_code`
	- `third_party_agents_enabled`
	:::

	##### 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ą:

	```bash
	export GITLAB_OAUTH_CLIENT_ID=your_application_id_here
	```

	Więcej informacji znajdziesz na stronie [opencode-gitlab-auth](https://www.npmjs.com/package/opencode-gitlab-auth).

	##### Konfiguracja

	Customize through `opencode.json`:

	```json title="opencode.json"
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"gitlab": {
	"options": {
	"instanceUrl": "https://gitlab.com"
	}
	}
	}
	}
	```

	##### Narzędzia GitLab API (opcjonalne, ale wysoce zalecane)

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

	```json title="opencode.json"
	{
	"$schema": "https://opencode.ai/config.json",
	"plugin": ["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:

	:::note
	Niektóre modele mogą wymagać [subskrypcji Pro+](https://github.com/features/Copilot/plans), aby z nich korzystać.

	Niektóre modele należy włączyć ręcznie w [ustawieniach GitHub Copilot](https://docs.github.com/en/Copilot/how-tos/use-ai-models/configure-access-to-ai-models#setup-for-individual-use).
	:::

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

	```txt
	/connect
	```

	2. Przejdź do [github.com/login/device](https://github.com/login/device) i wpisz kod.

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

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

	```txt
	/models
	```

	---

	### Google Vertex AI

	Aby używać Google Vertex AI z opencode:

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

	:::note
	Musisz mieć projekt Google Cloud z włączonym interfejsem API Vertex AI.
	:::

	2. Ustaw wymagane zmienne środowiskowe:
	- `GOOGLE_CLOUD_PROJECT`: identyfikator Twojego projektu Google Cloud
	- `VERTEX_LOCATION` (opcjonalnie): region Vertex AI (domyślnie `global`)
	- Uwierzytelnianie (wybierz jedno):
	- `GOOGLE_APPLICATION_CREDENTIALS`: Ścieżka do pliku klucza JSON konta usługi
	- Uwierzytelnij się za pomocą interfejsu CLI gcloud: `gcloud auth application-default login`

	Ustaw je podczas uruchamiania opencode.

	```bash
	GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id opencode
	```

	Lub dodaj je do swojego profilu bash.

	```bash title="~/.bash_profile"
	export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
	export GOOGLE_CLOUD_PROJECT=your-project-id
	export VERTEX_LOCATION=global
	```

	:::tip
	Region `global` poprawia dostępność i zmniejsza liczbę błędów bez dodatkowych kosztów. Użyj regionalnych punktów końcowych (np. `us-central1`) w celu spełnienia wymagań dotyczących miejsca przechowywania danych. [Dowiedz się więcej](https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/use-partner-models#regional_and_global_endpoints)
	:::

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

	```txt
	/models
	```

	---

	### Groq

	1. Przejdź do [konsoli Groq](https://console.groq.com/), kliknij Utwórz klucz API i skopiuj klucz.

	2. Uruchom komendę `/connect` i wyszukaj Groq.

	```txt
	/connect
	```

	3. Wprowadź klucz API dla dostawcy.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom polecenie `/models`, aby wybrać żądany.

	```txt
	/models
	```

	---

	### Hugging Face

	[Inference Providers Hugging Face](https://huggingface.co/docs/inference-providers) zapewniają dostęp do otwartych modeli obsługiwanych przez ponad 17 dostawców.

	1. Przejdź do [ustawień Hugging Face](https://huggingface.co/settings/tokens/new?ownUserPermissions=inference.serverless.write&tokenType=fineGrained), aby utworzyć token z uprawnieniami do wykonywania połączeń z dostawcami wnioskowania.

	2. Uruchom komendę `/connect` i wyszukaj Hugging Face.

	```txt
	/connect
	```

	3. Wprowadź swój token Hugging Face.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom polecenie `/models`, aby wybrać model taki jak _Kimi-K2-Instruct_ lub _GLM-4.6_.

	```txt
	/models
	```

	---

	### Helicone

	[Helicone](https://helicone.ai) 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.

	1. Udaj się do [Helicone](https://helicone.ai), utwórz konto i wygeneruj klucz API ze swojego panelu.

	2. Uruchom komendę `/connect` i wyszukaj Helicone.

	```txt
	/connect
	```

	3. Wprowadź swój klucz API Helicone.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom komendę `/models`, aby wybrać model.

	```txt
	/models
	```

	Więcej dostawców i zaawansowanych funkcji, takich jak buforowanie i ograniczanie szybkości, znajdziesz w [dokumentacji Helicone](https://docs.helicone.ai).

	#### 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](https://helicone.ai/models), będziesz go potrzebować, aby pobrać identyfikatory modeli, które chcesz dodać.

	```jsonc title="~/.config/opencode/opencode.jsonc"
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"helicone": {
	"npm": "@ai-sdk/openai-compatible",
	"name": "Helicone",
	"options": {
	"baseURL": "https://ai-gateway.helicone.ai",
	},
	"models": {
	"gpt-4o": {
	// Model ID (from Helicone's model directory page)
	"name": "GPT-4o", // Your own custom name for the model
	},
	"claude-sonnet-4-20250514": {
	"name": "Claude Sonnet 4",
	},
	},
	},
	},
	}
	```

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

	```jsonc title="~/.config/opencode/opencode.jsonc"
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"helicone": {
	"npm": "@ai-sdk/openai-compatible",
	"name": "Helicone",
	"options": {
	"baseURL": "https://ai-gateway.helicone.ai",
	"headers": {
	"Helicone-Cache-Enabled": "true",
	"Helicone-User-Id": "opencode",
	},
	},
	},
	},
	}
	```

	##### Śledzenie sesji

	Funkcja [Sesje](https://docs.helicone.ai/features/sessions) firmy Helicone umożliwia grupowanie powiązanych żądań LLM. Użyj wtyczki [opencode-helicone-session](https://github.com/H2Shami/opencode-helicone-session), aby automatycznie rejestrować każdą konwersację opencode jako sesję w Helicone.

	```bash
	npm install -g opencode-helicone-session
	```

	Dodaj go do swojej konfiguracji.

	```json title="opencode.json"
	{
	"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](https://docs.helicone.ai/helicone-headers/header-directory), 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](https://github.com/ggml-org/llama.cpp)

	```json title="opencode.json" "llama.cpp" {5, 6, 8, 10-15}
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"llama.cpp": {
	"npm": "@ai-sdk/openai-compatible",
	"name": "llama-server (local)",
	"options": {
	"baseURL": "http://127.0.0.1:8080/v1"
	},
	"models": {
	"qwen3-coder:a3b": {
	"name": "Qwen3-Coder: a3b-30b (local)",
	"limit": {
	"context": 128000,
	"output": 65536
	}
	}
	}
	}
	}
	}
	```

	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ń:

	1. Przejdź do [konsoli IO.NET](https://ai.io.net/), utwórz konto i wygeneruj klucz API.

	2. Uruchom komendę `/connect` i wyszukaj IO.NET.

	```txt
	/connect
	```

	3. Wprowadź swój klucz API IO.NET.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom komendę `/models`, aby wybrać model.

	```txt
	/models
	```

	---

	### LM Studio

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

	```json title="opencode.json" "lmstudio" {5, 6, 8, 10-14}
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"lmstudio": {
	"npm": "@ai-sdk/openai-compatible",
	"name": "LM Studio (local)",
	"options": {
	"baseURL": "http://127.0.0.1:1234/v1"
	},
	"models": {
	"google/gemma-3n-e4b": {
	"name": "Gemma 3n-e4b (local)"
	}
	}
	}
	}
	}
	```

	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:

	1. Przejdź do [konsoli Moonshot AI](https://platform.moonshot.ai/console), utwórz konto i kliknij Utwórz klucz API.

	2. Uruchom polecenie `/connect` i wyszukaj Moonshot AI.

	```txt
	/connect
	```

	3. Wprowadź klucz API Moonshot.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom komendę `/models`, aby wybrać _Kimi K2_.

	```txt
	/models
	```

	---

	### MiniMax

	1. Przejdź do [konsoli API MiniMax](https://platform.minimax.io/login), utwórz konto i wygeneruj klucz API.

	2. Uruchom komendę `/connect` i wyszukaj MiniMax.

	```txt
	/connect
	```

	3. Wprowadź swój klucz API MiniMax.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom komendę `/models`, aby wybrać model taki jak _M2.1_.

	```txt
	/models
	```

	---

	### Nebius Token Factory

	1. Przejdź do [konsoli Nebius Token Factory](https://tokenfactory.nebius.com/), utwórz konto i kliknij Dodaj klucz.

	2. Uruchom komendę `/connect` i wyszukaj Nebius Token Factory.

	```txt
	/connect
	```

	3. Wprowadź klucz API Nebius Token Factory.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom polecenie `/models`, aby wybrać model taki jak _Kimi K2 Instruct_.

	```txt
	/models
	```

	---

	### Ollama

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

	:::tip
	Ollama może automatycznie skonfigurować się pod kątem opencode. Aby uzyskać szczegółowe informacje, zobacz [dokumentację integracji Ollama](https://docs.ollama.com/integrations/opencode).
	:::

	```json title="opencode.json" "ollama" {5, 6, 8, 10-14}
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"ollama": {
	"npm": "@ai-sdk/openai-compatible",
	"name": "Ollama (local)",
	"options": {
	"baseURL": "http://localhost:11434/v1"
	},
	"models": {
	"llama2": {
	"name": "Llama 2"
	}
	}
	}
	}
	}
	```

	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.

	:::tip
	Jeśli wywołania narzędzi nie działają, spróbuj zwiększyć `num_ctx` w Ollama. Zacznij około 16 tys. - 32 tys.
	:::

	---

	### Ollama Cloud

	Aby korzystać z Ollama Cloud z opencode:

	1. Udaj się do [https://ollama.com/](https://ollama.com/) i zaloguj się lub utwórz konto.

	2. Przejdź do Ustawienia > Klucze i kliknij Dodaj klucz API, aby wygenerować nowy klucz API.

	3. Skopiuj klucz API do użycia w opencode.

	4. Uruchom polecenie `/connect` i wyszukaj Ollama Cloud.

	```txt
	/connect
	```

	5. Wprowadź swój klucz API Ollama Cloud.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	6. Ważne: Przed użyciem modeli chmurowych w opencode musisz pobrać informacje o modelu lokalnie:

	```bash
	ollama pull gpt-oss:20b-cloud
	```

	7. Uruchom polecenie `/models`, aby wybrać model Ollama Cloud.

	```txt
	/models
	```

	---

	### OpenAI

	Zalecamy zarejestrowanie się w [ChatGPT Plus lub Pro](https://chatgpt.com/pricing).

	1. Po zarejestrowaniu się uruchom komendę `/connect` i wybierz OpenAI.

	```txt
	/connect
	```

	2. Tutaj możesz wybrać opcję ChatGPT Plus/Pro, co spowoduje otwarcie przeglądarki
	i poproś o uwierzytelnienie.

	```txt
	┌ Select auth method
	│
	│ ChatGPT Plus/Pro
	│ Manually enter API Key
	└
	```

	3. Teraz wszystkie modele OpenAI powinny być dostępne po użyciu polecenia `/models`.

	```txt
	/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](/docs/zen).

	1. Zaloguj się do <a href={console}>OpenCode Zen</a> i kliknij Utwórz klucz API.

	2. Uruchom polecenie `/connect` i wyszukaj OpenCode Zen.

	```txt
	/connect
	```

	3. Wprowadź klucz API opencode.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom polecenie `/models`, aby wybrać model taki jak _Qwen 3 Coder 480B_.

	```txt
	/models
	```

	---

	### OpenRouter

	1. Przejdź do [panelu OpenRouter](https://openrouter.ai/settings/keys), kliknij Utwórz klucz API i skopiuj klucz.

	2. Uruchom komendę `/connect` i wyszukaj OpenRouter.

	```txt
	/connect
	```

	3. Wprowadź klucz API dla dostawcy.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Wiele modeli OpenRouter jest domyślnie załadowanych fabrycznie. Uruchom komendę `/models`, aby wybrać ten, który chcesz.

	```txt
	/models
	```

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

	```json title="opencode.json" {6}
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"openrouter": {
	"models": {
	"somecoolnewmodel": {}
	}
	}
	}
	}
	```

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

	```json title="opencode.json"
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"openrouter": {
	"models": {
	"moonshotai/kimi-k2": {
	"options": {
	"provider": {
	"order": ["baseten"],
	"allow_fallbacks": false
	}
	}
	}
	}
	}
	}
	}
	```

	---

	### SAP AI Core

	SAP AI Core zapewnia dostęp do ponad 40 modeli z OpenAI, Anthropic, Google, Amazon, Meta, Mistral i AI21 za pośrednictwem ujednoliconej platformy.

	1. Przejdź do [SAP BTP Cockpit](https://account.hana.ondemand.com/), przejdź do instancji usługi SAP AI Core i utwórz klucz usługi.

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

	2. Uruchom polecenie `/connect` i wyszukaj SAP AI Core.

	```txt
	/connect
	```

	3. Wpisz swój klucz usługi JSON.

	```txt
	┌ Service key
	│
	│
	└ enter
	```

	Lub ustaw zmienną środowiskową `AICORE_SERVICE_KEY`:

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

	Lub dodaj go do swojego profilu bash:

	```bash title="~/.bash_profile"
	export AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}'
	```

	4. Opcjonalnie ustaw identyfikator wdrożenia i grupę zasobów:

	```bash
	AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode
	```

	:::note
	Te ustawienia są opcjonalne i należy je skonfigurować zgodnie z konfiguracją SAP AI Core.
	:::

	5. Uruchom polecenie `/models`, aby wybrać spośród ponad 40 dostępnych modeli.

	```txt
	/models
	```

	---

	### STACKIT

	STACKIT AI Model Serving zapewnia w pełni zarządzane suwerenne środowisko hostingu dla modeli AI, koncentrując się na LLM, takich jak Llama, Mistral i Qwen, z maksymalną suwerennością danych na infrastrukturze europejskiej.

	1. Przejdź do [portalu STACKIT](https://portal.stackit.cloud), przejdź do AI Model Serving, i utwórz token autoryzacyjny dla swojego projektu.

	:::tip
	Musisz posiadać konto klienta STACKIT, konto użytkownika i projekt przed utworzeniem tokenów autoryzacyjnych.
	:::

	2. Uruchom polecenie `/connect` i wyszukaj STACKIT.

	```txt
	/connect
	```

	3. Wprowadź swój token autoryzacyjny STACKIT AI Model Serving.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom polecenie `/models`, aby wybrać jeden z dostępnych modeli, np. _Qwen3-VL 235B_ lub _Llama 3.3 70B_.

	```txt
	/models
	```

	---

	### OVHcloud AI Endpoints

	1. Przejdź do [panelu OVHcloud](https://ovh.com/manager). Przejdź do sekcji `Public Cloud`, `AI & Machine Learning` > `AI Endpoints` i na karcie `API Keys` kliknij Utwórz nowy klucz API.

	2. Uruchom polecenie `/connect` i wyszukaj Punkty końcowe AI OVHcloud.

	```txt
	/connect
	```

	3. Wpisz klucz API punktów końcowych AI OVHcloud.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom polecenie `/models`, aby wybrać model taki jak _gpt-oss-120b_.

	```txt
	/models
	```

	---

	### Scaleway

	Aby używać [generatywnych interfejsów API Scaleway](https://www.scaleway.com/en/docs/generative-apis/) z opencode:

	1. Przejdź do [Ustawień uprawnień konsoli Scaleway](https://console.scaleway.com/iam/api-keys), aby wygenerować nowy klucz API.

	2. Uruchom komendę `/connect` i wyszukaj Scaleway.

	```txt
	/connect
	```

	3. Wprowadź swój klucz API Scaleway.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom komendę `/models`, aby wybrać model taki jak _devstral-2-123b-instruct-2512_ lub _gpt-oss-120b_.

	```txt
	/models
	```

	---

	### Together AI

	1. Przejdź do [konsoli Together AI](https://api.together.ai), utwórz konto i kliknij Dodaj klucz.

	2. Uruchom komendę `/connect` i wyszukaj Together AI.

	```txt
	/connect
	```

	3. Wprowadź klucz API Together AI.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom polecenie `/models`, aby wybrać model taki jak _Kimi K2 Instruct_.

	```txt
	/models
	```

	---

	### Venice AI

	1. Przejdź do [konsoli Venice AI](https://venice.ai), utwórz konto i wygeneruj klucz API.

	2. Uruchom polecenie `/connect` i wyszukaj Venice AI.

	```txt
	/connect
	```

	3. Wprowadź klucz API Venice AI.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom polecenie `/models`, aby wybrać model taki jak _Llama 3.3 70B_.

	```txt
	/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.

	1. Przejdź do [panelu Vercel](https://vercel.com/), przejdź do karty AI Gateway i kliknij Klucze API, aby utworzyć nowy klucz API.

	2. Uruchom polecenie `/connect` i wyszukaj Vercel AI Gateway.

	```txt
	/connect
	```

	3. Wprowadź klucz API Vercel AI Gateway.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom komendę `/models`, aby wybrać model.

	```txt
	/models
	```

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

	```json title="opencode.json"
	{
	"$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

	1. Przejdź do [konsoli xAI](https://console.x.ai/), utwórz konto i wygeneruj klucz API.

	2. Uruchom komendę `/connect` i wyszukaj xAI.

	```txt
	/connect
	```

	3. Wprowadź swój klucz API xAI.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom polecenie `/models`, aby wybrać model taki jak _Grok Beta_.

	```txt
	/models
	```

	---

	### Z.AI

	1. Przejdź do [konsoli API Z.AI](https://z.ai/manage-apikey/apikey-list), utwórz konto i kliknij Utwórz nowy klucz API.

	2. Uruchom komendę `/connect` i wyszukaj Z.AI.

	```txt
	/connect
	```

	Jeżeli jesteś abonentem Planu kodowania GLM, wybierz Plan kodowania Z.AI.

	3. Wpisz swój klucz API Z.AI.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Uruchom komendę `/models`, aby wybrać model taki jak _GLM-4.7_.

	```txt
	/models
	```

	---

	### ZenMux

	1. Przejdź do [panelu ZenMux](https://zenmux.ai/settings/keys), kliknij Utwórz klucz API i skopiuj klucz.

	2. Uruchom polecenie `/connect` i wyszukaj ZenMux.

	```txt
	/connect
	```

	3. Wprowadź klucz API dla dostawcy.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Wiele modeli ZenMux jest domyślnie załadowanych fabrycznie. Uruchom komendę `/models`, aby wybrać żądany model.

	```txt
	/models
	```

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

	```json title="opencode.json" {6}
	{
	"$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`:

	:::tip
	Możesz użyć dowolnego dostawcy kompatybilnego z OpenAI z opencode. Większość nowoczesnych dostawców sztucznej inteligencji oferuje interfejsy API kompatybilne z OpenAI.
	:::

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

	```bash
	$ /connect

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

	2. Wprowadź unikalny identyfikator dostawcy.

	```bash
	$ /connect

	┌ Add credential
	│
	◇ Enter provider id
	│ myprovider
	└
	```

	:::note
	Wybierz niezapomniany identyfikator, użyjesz go w swoim pliku konfiguracyjnym.
	:::

	3. Wprowadź klucz API dla dostawcy.

	```bash
	$ /connect

	┌ Add credential
	│
	▲ This only stores a credential for myprovider - you will need to configure it in opencode.json, check the docs for examples.
	│
	◇ Enter your API key
	│ sk-...
	└
	```

	4. Utwórz lub zaktualizuj plik `opencode.json` w katalogu projektu:

	```json title="opencode.json" ""myprovider"" {5-15}
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"myprovider": {
	"npm": "@ai-sdk/openai-compatible",
	"name": "My AI ProviderDisplay Name",
	"options": {
	"baseURL": "https://api.myprovider.com/v1"
	},
	"models": {
	"my-model-name": {
	"name": "My Model Display Name"
	}
	}
	}
	}
	}
	```

	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.

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

	```json title="opencode.json" {9,11,17-20}
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"myprovider": {
	"npm": "@ai-sdk/openai-compatible",
	"name": "My AI ProviderDisplay Name",
	"options": {
	"baseURL": "https://api.myprovider.com/v1",
	"apiKey": "{env:ANTHROPIC_API_KEY}",
	"headers": {
	"Authorization": "Bearer custom-token"
	}
	},
	"models": {
	"my-model-name": {
	"name": "My Model Display Name",
	"limit": {
	"context": 200000,
	"output": 65536
	}
	}
	}
	}
	}
	}
	```

	Szczegóły konfiguracji:

	- apiKey: Ustaw przy użyciu składni zmiennej `env`, [dowiedz się więcej](/docs/config#env-vars).
	- 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.

	---

	## Rozwiązywanie problemów

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

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

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