opencode/packages/web/src/content/docs/pl/providers.mdx at b7b8b06011ff58f7d52dc0f73df67b459d9f5dce · anomalyco/opencode

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

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.

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

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

Uruchom polecenie /connect w TUI, wybierz OpenCode Zen 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.

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.

Uruchom polecenie /connect w TUI, wybierz OpenCode Go 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.

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

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.

:::tip 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:
```
# 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:
```
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:
```
{
  "$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:
```
{
  "$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. :::
Uruchom komendę /models, aby wybrać żądany model.
```
/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:

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

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

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 — aplikację desktopową uruchamiającą lokalne LLM-y za serwerem API zgodnym z OpenAI (domyślny endpoint http://127.0.0.1:1337/v1).

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

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.

:::note 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ą:
```
AZURE_RESOURCE_NAME=XXX opencode
```
Lub dodaj go do swojego profilu bash:
```
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.

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

AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode

Lub dodaj go do swojego profilu bash:

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
```
Lub ustaw go jako zmienną środowiskową.
```
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 V4 Pro.
```
/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
```

FrogBot

Przejdź do FrogBot dashboard, utwórz konto i wygeneruj klucz API.
Uruchom polecenie /connect i wyszukaj FrogBot.
```
/connect
```
Wprowadź klucz API FrogBot.
```
┌ 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.

Użycie osobistego tokenu dostępu
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

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

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

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

Platforma Duo Agent dla użytkownika, grupy lub instancji
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ą:

export GITLAB_OAUTH_CLIENT_ID=your_application_id_here

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

Konfiguracja

Customize through 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.):

{
  "$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+, aby z nich korzystać.

Niektóre modele należy włączyć ręcznie w ustawieniach GitHub Copilot. :::

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.

:::note 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)
- 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.
```
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id opencode
```
Lub dodaj je do swojego profilu bash.
```
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 :::

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

:::tip Ollama może automatycznie skonfigurować się pod kątem opencode. Aby uzyskać szczegółowe informacje, zobacz dokumentację integracji 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"
        }
      }
    }
  }
}

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:

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

:::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. :::
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:
```
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. :::
Uruchom polecenie /models, aby wybrać spośród ponad 40 dostępnych modeli.
```
/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.

Przejdź do portalu STACKIT, 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. :::
Uruchom polecenie /connect i wyszukaj STACKIT.
```
/connect
```
Wprowadź swój token autoryzacyjny STACKIT AI Model Serving.
```
┌ API key
│
│
└ enter
```
Uruchom polecenie /models, aby wybrać jeden z dostępnych modeli, np. Qwen3-VL 235B lub Llama 3.3 70B.
```
/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.
```
{
  "$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. :::

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

$ /connect

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

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

┌  Add credential
│
◇  Enter provider id
│  myprovider
└
```
:::note 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:
```
{
  "$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.

Rozwiązywanie problemów

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.

FilesExpand file tree

providers.mdx

Latest commit

History

providers.mdx

File metadata and controls

Credentials

Konfiguracja

Base URL

OpenCode Zen

OpenCode Go

Katalog

302.AI

Amazon Bedrock

Zmienne środowiskowe (Szybki start)

Plik konfiguracyjny (zalecane)

Zaawansowane: Punkty końcowe VPC

Metody uwierzytelniania

Kolejność uwierzytelniania

Anthropic

Użycie kluczy API

Atomic Chat

Azure OpenAI

Azure Cognitive Services

Baseten

Cerebras

Cloudflare AI Gateway

Cortecs

DeepSeek

Deep Infra

FrogBot

Fireworks AI

GitLab Duo

Using OAuth (Recommended)

Użycie osobistego tokenu dostępu

Self-Hosted GitLab

OAuth dla instancji hostowanych samodzielnie

Konfiguracja

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

GitHub Copilot

Google Vertex AI

Groq

Hugging Face

Helicone

Opcjonalna konfiguracja

Niestandardowe nagłówki

Śledzenie sesji

Najczęstsze nagłówki Helicone

llama.cpp

IO.NET

LM Studio

Moonshot AI

MiniMax

Nebius Token Factory

Ollama

Ollama Cloud

OpenAI

Użycie kluczy API

OpenCode Zen

OpenRouter

SAP AI Core

STACKIT

OVHcloud AI Endpoints

Scaleway

Together AI

Venice AI

Vercel AI Gateway

xAI

Z.AI

ZenMux

Niestandardowy dostawca

Przykład

Rozwiązywanie problemów