Buckets:

GHHG10
/

CodeServer

Files

xet

GHHG10/CodeServer / opencode /packages /web /src /content /docs /it /providers.mdx

GHHG10

about 2 months ago

download

raw

47.4 kB

	---
	title: Provider
	description: Usa qualsiasi provider LLM in OpenCode.
	---

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

	OpenCode usa [AI SDK](https://ai-sdk.dev/) e [Models.dev](https://models.dev) per supportare oltre 75 provider LLM e anche modelli locali.

	Per aggiungere un provider devi:

	1. Aggiungere le API key del provider con il comando `/connect`.
	2. Configurare il provider nella configurazione di OpenCode.

	---

	### Credenziali

	Quando aggiungi le API key di un provider con `/connect`, vengono salvate
	in `~/.local/share/opencode/auth.json`.

	---

	### Configurazione

	Puoi personalizzare i provider tramite la sezione `provider` nella
	configurazione di OpenCode.

	---

	#### URL base

	Puoi personalizzare l'URL base per qualsiasi provider impostando l'opzione `baseURL`. E utile quando usi servizi proxy o endpoint personalizzati.

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

	---

	## OpenCode Zen

	OpenCode Zen e una lista di modelli forniti dal team OpenCode, testati e
	verificati per funzionare bene con OpenCode. [Scopri di piu](/docs/zen).

	:::tip
	Se sei all'inizio, ti consigliamo di partire da OpenCode Zen.
	:::

	1. Esegui `/connect` nella TUI, seleziona opencode e vai su [opencode.ai/auth](https://opencode.ai/auth).

	```txt
	/connect
	```

	2. Accedi, aggiungi i dati di fatturazione e copia la tua API key.

	3. Incolla la tua API key.

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

	4. Esegui `/models` nella TUI per vedere la lista di modelli consigliati.

	```txt
	/models
	```

	Funziona come qualsiasi altro provider in OpenCode ed e totalmente opzionale.

	---

	## Elenco

	Vediamo alcuni provider nel dettaglio. Se vuoi aggiungerne uno
	all'elenco, apri pure una PR.

	:::note
	Non vedi un provider qui? Invia una PR.
	:::

	---

	### 302.AI

	1. Vai alla [console di 302.AI](https://302.ai/), crea un account e genera una chiave API.

	2. Esegui il comando `/connect` e cerca 302.AI.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di 302.AI.

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

	4. Esegui il comando `/models` per selezionare un modello.

	```txt
	/models
	```

	---

	### Amazon Bedrock

	Per usare Amazon Bedrock con OpenCode:

	1. Vai al Model catalog nella console Amazon Bedrock e richiedi
	accesso ai modelli che vuoi usare.

	:::tip
	Devi avere accesso al modello che vuoi in Amazon Bedrock.
	:::

	2. Configura l'autenticazione usando uno dei seguenti metodi:

	***

	#### Variabili d'ambiente (Avvio rapido)

	Imposta una di queste variabili d'ambiente mentre esegui 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
	```

	Oppure aggiungile al tuo profilo bash:

	```bash title="~/.bash_profile"
	export AWS_PROFILE=my-dev-profile
	export AWS_REGION=us-east-1
	```

	***

	#### File di configurazione (Consigliato)

	Per configurazione specifica del progetto o persistente, usa `opencode.json`:

	```json title="opencode.json"
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"amazon-bedrock": {
	"options": {
	"region": "us-east-1",
	"profile": "my-aws-profile"
	}
	}
	}
	}
	```

	Opzioni disponibili:
	- `region` - Regione AWS (ad es. `us-east-1`, `eu-west-1`)
	- `profile` - Profilo AWS nominato da `~/.aws/credentials`
	- `endpoint` - URL endpoint personalizzato per VPC endpoints (alias per l'opzione generica `baseURL`)

	:::tip
	Le opzioni del file di configurazione hanno la precedenza sulle variabili d'ambiente.
	:::

	***

	#### Avanzato: VPC Endpoints

	Se stai usando VPC endpoints per 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
	L'opzione `endpoint` è un alias per l'opzione generica `baseURL`, usando terminologia specifica AWS. Se vengono specificati sia `endpoint` sia `baseURL`, `endpoint` ha la precedenza.
	:::

	***

	#### Metodi di autenticazione
	- `AWS_ACCESS_KEY_ID` / `AWS_SECRET_ACCESS_KEY`: Crea un utente IAM e genera chiavi di accesso nella Console AWS
	- `AWS_PROFILE`: Usa profili nominati da `~/.aws/credentials`. Configura prima con `aws configure --profile my-profile` o `aws sso login`
	- `AWS_BEARER_TOKEN_BEDROCK`: Genera chiavi API a lungo termine dalla console Amazon Bedrock
	- `AWS_WEB_IDENTITY_TOKEN_FILE` / `AWS_ROLE_ARN`: Per EKS IRSA (IAM Roles for Service Accounts) o altri ambienti Kubernetes con federazione OIDC. Queste variabili d'ambiente vengono iniettate automaticamente da Kubernetes quando usi le annotazioni del service account.

	***

	#### Precedenza autenticazione

	Amazon Bedrock usa la seguente priorità di autenticazione:
	1. Bearer Token - Variabile d'ambiente `AWS_BEARER_TOKEN_BEDROCK` o token dal comando `/connect`
	2. AWS Credential Chain - Profilo, chiavi di accesso, credenziali condivise, ruoli IAM, Web Identity Tokens (EKS IRSA), metadati istanza

	:::note
	Quando è impostato un bearer token (tramite `/connect` o `AWS_BEARER_TOKEN_BEDROCK`), ha la precedenza su tutti i metodi di credenziali AWS inclusi i profili configurati.
	:::

	3. Esegui il comando `/models` per selezionare il modello che vuoi.

	```txt
	/models
	```

	:::note
	Per profili di inferenza personalizzati, usa il nome del modello e del provider nella chiave e imposta la proprietà `id` all'arn. Questo assicura una cache corretta.
	:::

	```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. Una volta registrato, esegui il comando `/connect` e seleziona Anthropic.

	```txt
	/connect
	```

	2. Qui puoi selezionare l'opzione Claude Pro/Max: aprirà il tuo browser
	e ti chiederà di autenticarti.

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

	3. Ora tutti i modelli Anthropic dovrebbero essere disponibili quando usi il comando `/models`.

	```txt
	/models
	```

	:::info
	L'uso dell'abbonamento Claude Pro/Max in OpenCode non è ufficialmente supportato da [Anthropic](https://anthropic.com).
	:::

	##### Usare chiavi API

	Puoi anche selezionare Create an API Key se non hai un abbonamento Pro/Max. Aprirà il browser, ti chiederà di accedere ad Anthropic e ti darà un codice da incollare nel terminale.

	Oppure se hai già una chiave API, puoi selezionare Manually enter API Key e incollarla nel terminale.

	---

	### Atomic Chat

	Puoi configurare opencode per utilizzare modelli locali tramite [Atomic Chat](https://atomic.chat), un'applicazione desktop che esegue LLM locali dietro un server API compatibile OpenAI (endpoint predefinito `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>"
	}
	}
	}
	}
	}
	```

	In questo esempio:

	- `atomic-chat` è l'ID personalizzato del provider. Può essere qualsiasi stringa.
	- `npm` specifica il pacchetto da utilizzare per questo provider. Qui viene usato `@ai-sdk/openai-compatible` per qualsiasi API compatibile OpenAI.
	- `name` è il nome visualizzato del provider nell'interfaccia.
	- `options.baseURL` è l'endpoint del server locale. Modifica host e porta in base alla tua configurazione Atomic Chat.
	- `models` è una mappa di ID modello ai rispettivi nomi visualizzati. Ogni ID deve corrispondere all'`id` restituito da `GET /v1/models` — esegui `curl http://127.0.0.1:1337/v1/models` per elencare gli ID attualmente caricati in Atomic Chat.

	:::tip
	Se le chiamate agli strumenti non funzionano bene, scegli un modello caricato con buon supporto per il tool calling (ad esempio, una variante Qwen-Coder o DeepSeek-Coder).
	:::

	---

	### Azure OpenAI

	:::note
	Se incontri errori "I'm sorry, but I cannot assist with that request", prova a cambiare il filtro contenuti da DefaultV2 a Default nella tua risorsa Azure.
	:::

	1. Vai al [portale Azure](https://portal.azure.com/) e crea una risorsa Azure OpenAI. Ti serviranno:
	- Resource name: Diventa parte del tuo endpoint API (`https://RESOURCE_NAME.openai.azure.com/`)
	- API key: O `KEY 1` o `KEY 2` dalla tua risorsa

	2. Vai su [Azure AI Foundry](https://ai.azure.com/) e fai il deploy di un modello.

	:::note
	Il nome del deployment deve corrispondere al nome del modello affinché opencode funzioni correttamente.
	:::

	3. Esegui il comando `/connect` e cerca Azure.

	```txt
	/connect
	```

	4. Inserisci la tua chiave API.

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

	5. Imposta il nome della risorsa come variabile d'ambiente:

	```bash
	AZURE_RESOURCE_NAME=XXX opencode
	```

	Oppure aggiungilo al tuo profilo bash:

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

	6. Esegui il comando `/models` per selezionare il tuo modello deployato.

	```txt
	/models
	```

	---

	### Azure Cognitive Services

	1. Vai al [portale Azure](https://portal.azure.com/) e crea una risorsa Azure OpenAI. Ti serviranno:
	- Resource name: Diventa parte del tuo endpoint API (`https://AZURE_COGNITIVE_SERVICES_RESOURCE_NAME.cognitiveservices.azure.com/`)
	- API key: O `KEY 1` o `KEY 2` dalla tua risorsa

	2. Vai su [Azure AI Foundry](https://ai.azure.com/) e fai il deploy di un modello.

	:::note
	Il nome del deployment deve corrispondere al nome del modello affinché opencode funzioni correttamente.
	:::

	3. Esegui il comando `/connect` e cerca Azure Cognitive Services.

	```txt
	/connect
	```

	4. Inserisci la tua chiave API.

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

	5. Imposta il nome della risorsa come variabile d'ambiente:

	```bash
	AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
	```

	Oppure aggiungilo al tuo profilo bash:

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

	6. Esegui il comando `/models` per selezionare il tuo modello deployato.

	```txt
	/models
	```

	---

	### Baseten

	1. Vai su [Baseten](https://app.baseten.co/), crea un account e genera una chiave API.

	2. Esegui il comando `/connect` e cerca Baseten.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di Baseten.

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

	4. Esegui il comando `/models` per selezionare un modello.

	```txt
	/models
	```

	---

	### Cerebras

	1. Vai alla [console di Cerebras](https://inference.cerebras.ai/), crea un account e genera una chiave API.

	2. Esegui il comando `/connect` e cerca Cerebras.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di Cerebras.

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

	4. Esegui il comando `/models` per selezionare un modello come _Qwen 3 Coder 480B_.

	```txt
	/models
	```

	---

	### Cloudflare AI Gateway

	Cloudflare AI Gateway ti permette di accedere a modelli di OpenAI, Anthropic, Workers AI e altri tramite un endpoint unificato. Con la [fatturazione unificata](https://developers.cloudflare.com/ai-gateway/features/unified-billing/) non hai bisogno di chiavi API separate per ogni provider.

	1. Vai alla [dashboard di Cloudflare](https://dash.cloudflare.com/), naviga in AI > AI Gateway e crea un nuovo gateway.

	2. Imposta il tuo Account ID e Gateway ID come variabili d'ambiente.

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

	3. Esegui il comando `/connect` e cerca Cloudflare AI Gateway.

	```txt
	/connect
	```

	4. Inserisci il tuo API token di Cloudflare.

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

	Oppure impostalo come variabile d'ambiente.

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

	5. Esegui il comando `/models` per selezionare un modello.

	```txt
	/models
	```

	Puoi anche aggiungere modelli tramite la tua configurazione di 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. Vai alla [console di Cortecs](https://cortecs.ai/), crea un account e genera una chiave API.

	2. Esegui il comando `/connect` e cerca Cortecs.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di Cortecs.

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

	4. Esegui il comando `/models` per selezionare un modello come _Kimi K2 Instruct_.

	```txt
	/models
	```

	---

	### DeepSeek

	1. Vai alla [console di DeepSeek](https://platform.deepseek.com/), crea un account e clicca Create new API key.

	2. Esegui il comando `/connect` e cerca DeepSeek.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di DeepSeek.

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

	4. Esegui il comando `/models` per selezionare un modello DeepSeek come _DeepSeek V4 Pro_.

	```txt
	/models
	```

	---

	### Deep Infra

	1. Vai alla [dashboard di Deep Infra](https://deepinfra.com/dash), crea un account e genera una chiave API.

	2. Esegui il comando `/connect` e cerca Deep Infra.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di Deep Infra.

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

	4. Esegui il comando `/models` per selezionare un modello.

	```txt
	/models
	```

	---

	### FrogBot

	1. Vai alla [dashboard di FrogBot](https://app.frogbot.ai/signup), crea un account e genera una chiave API.

	2. Esegui il comando `/connect` e cerca FrogBot.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di FrogBot.

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

	4. Esegui il comando `/models` per selezionare un modello.

	```txt
	/models
	```

	---

	### Fireworks AI

	1. Vai alla [console di Fireworks AI](https://app.fireworks.ai/), crea un account e clicca Create API Key.

	2. Esegui il comando `/connect` e cerca Fireworks AI.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di Fireworks AI.

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

	4. Esegui il comando `/models` per selezionare un modello come _Kimi K2 Instruct_.

	```txt
	/models
	```

	---

	### GitLab Duo

	GitLab Duo fornisce una chat agentic basata su AI con capacità di chiamata strumenti nativa tramite il proxy Anthropic di GitLab.

	1. Esegui il comando `/connect` e seleziona GitLab.

	```txt
	/connect
	```

	2. Scegli il tuo metodo di autenticazione:

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

	#### Usando OAuth (Consigliato)

	Seleziona OAuth e il tuo browser si aprirà per l'autorizzazione.

	#### Usando Personal Access Token
	1. Vai a [GitLab User Settings > Access Tokens](https://gitlab.com/-/user_settings/personal_access_tokens)
	2. Clicca Add new token
	3. Nome: `OpenCode`, Scopes: `api`
	4. Copia il token (inizia con `glpat-`)
	5. Inseriscilo nel terminale

	3. Esegui il comando `/models` per vedere i modelli disponibili.

	```txt
	/models
	```

	Sono disponibili tre modelli basati su Claude:
	- duo-chat-haiku-4-5 (Default) - Risposte veloci per task rapidi
	- duo-chat-sonnet-4-5 - Prestazioni bilanciate per la maggior parte dei flussi di lavoro
	- duo-chat-opus-4-5 - Più capace per analisi complesse

	:::note
	Puoi anche specificare la variabile d'ambiente 'GITLAB_TOKEN' se non vuoi
	salvare il token nello storage di auth di opencode.
	:::

	##### GitLab Self-Hosted

	:::note[nota di compliance]
	OpenCode usa un modello piccolo per alcuni task AI come generare il titolo della sessione.
	È configurato per usare gpt-5-nano di default, ospitato da Zen. Per bloccare OpenCode
	a usare solo la tua istanza GitLab self-hosted, aggiungi quanto segue al tuo
	file `opencode.json`. Si raccomanda anche di disabilitare la condivisione sessioni.

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

	:::

	Per istanze GitLab self-hosted:

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

	Se la tua istanza esegue un AI Gateway personalizzato:

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

	Oppure aggiungi al tuo profilo 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
	Il tuo amministratore GitLab deve abilitare quanto segue:

	1. [Duo Agent Platform](https://docs.gitlab.com/user/duo_agent_platform/turn_on_off/) per l'utente, gruppo o istanza
	2. Feature flags (via Rails console):
	- `agent_platform_claude_code`
	- `third_party_agents_enabled`
	:::

	##### OAuth per istanze Self-Hosted

	Per far funzionare OAuth per la tua istanza self-hosted, devi creare
	una nuova applicazione (Settings → Applications) con l'
	URL di callback `http://127.0.0.1:8080/callback` e i seguenti scope:

	- api (Accedi all'API per tuo conto)
	- read_user (Leggi le tue informazioni personali)
	- read_repository (Consenti accesso in sola lettura al repository)

	Poi esponi l'ID applicazione come variabile d'ambiente:

	```bash
	export GITLAB_OAUTH_CLIENT_ID=your_application_id_here
	```

	Maggior documentazione sulla homepage di [opencode-gitlab-auth](https://www.npmjs.com/package/opencode-gitlab-auth).

	##### Configurazione

	Personalizza tramite `opencode.json`:

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

	##### Strumenti API GitLab (Opzionale, ma altamente raccomandato)

	Per accedere agli strumenti GitLab (merge requests, issues, pipelines, CI/CD, ecc.):

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

	Questo plugin offre funzionalita complete per la gestione dei repository GitLab, incluse revisioni delle MR, tracciamento dei problemi, monitoraggio delle pipeline e altro.

	---

	### GitHub Copilot

	Per usare il tuo abbonamento GitHub Copilot con opencode:

	:::note
	Alcuni modelli potrebbero richiedere un [abbonamento Pro+](https://github.com/features/copilot/plans) per essere utilizzati.

	Alcuni modelli devono essere abilitati manualmente nelle tue [impostazioni GitHub Copilot](https://docs.github.com/en/copilot/how-tos/use-ai-models/configure-access-to-ai-models#setup-for-individual-use).
	:::

	1. Esegui il comando `/connect` e cerca GitHub Copilot.

	```txt
	/connect
	```

	2. Vai su [github.com/login/device](https://github.com/login/device) e inserisci il codice.

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

	3. Ora esegui il comando `/models` per selezionare il modello che vuoi.

	```txt
	/models
	```

	---

	### Google Vertex AI

	Per usare Google Vertex AI con OpenCode:

	1. Vai al Model Garden nella Google Cloud Console e controlla i
	modelli disponibili nella tua regione.

	:::note
	Devi avere un progetto Google Cloud con l'API Vertex AI abilitata.
	:::

	2. Imposta le variabili d'ambiente richieste:
	- `GOOGLE_CLOUD_PROJECT`: Il tuo ID progetto Google Cloud
	- `VERTEX_LOCATION` (opzionale): La regione per Vertex AI (predefinito `global`)
	- Autenticazione (scegline una):
	- `GOOGLE_APPLICATION_CREDENTIALS`: Percorso al file JSON della chiave del tuo service account
	- Autenticati usando la CLI gcloud: `gcloud auth application-default login`

	Impostale mentre esegui opencode.

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

	Oppure aggiungile al tuo profilo 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
	La regione `global` migliora la disponibilità e riduce gli errori senza costi extra. Usa endpoint regionali (ad es. `us-central1`) per requisiti di residenza dei dati. [Scopri di più](https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/use-partner-models#regional_and_global_endpoints)
	:::

	3. Esegui il comando `/models` per selezionare il modello che vuoi.

	```txt
	/models
	```

	---

	### Groq

	1. Vai alla [console di Groq](https://console.groq.com/), clicca Create API Key e copia la chiave.

	2. Esegui il comando `/connect` e cerca Groq.

	```txt
	/connect
	```

	3. Inserisci la chiave API per il provider.

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

	4. Esegui il comando `/models` per selezionare quello che vuoi.

	```txt
	/models
	```

	---

	### Hugging Face

	[Hugging Face Inference Providers](https://huggingface.co/docs/inference-providers) fornisce accesso a modelli open supportati da 17+ provider.

	1. Vai alle [impostazioni di Hugging Face](https://huggingface.co/settings/tokens/new?ownUserPermissions=inference.serverless.write&tokenType=fineGrained) per creare un token con il permesso di effettuare chiamate agli Inference Providers.

	2. Esegui il comando `/connect` e cerca Hugging Face.

	```txt
	/connect
	```

	3. Inserisci il tuo token Hugging Face.

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

	4. Esegui il comando `/models` per selezionare un modello come _Kimi-K2-Instruct_ o _GLM-4.6_.

	```txt
	/models
	```

	---

	### Helicone

	[Helicone](https://helicone.ai) è una piattaforma di osservabilità LLM che fornisce logging, monitoraggio e analisi per le tue applicazioni AI. L'AI Gateway di Helicone instrada automaticamente le tue richieste al provider appropriato in base al modello.

	1. Vai su [Helicone](https://helicone.ai), crea un account e genera una chiave API dalla tua dashboard.

	2. Esegui il comando `/connect` e cerca Helicone.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di Helicone.

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

	4. Esegui il comando `/models` per selezionare un modello.

	```txt
	/models
	```

	Per altri provider e funzionalità avanzate come caching e rate limiting, controlla la [documentazione di Helicone](https://docs.helicone.ai).

	#### Config opzionali

	Nel caso vedessi una funzionalità o un modello di Helicone che non viene configurato automaticamente da opencode, puoi sempre configurarlo tu stesso.

	Ecco la [Model Directory di Helicone](https://helicone.ai/models), ti servirà per recuperare gli ID dei modelli che vuoi aggiungere.

	```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",
	},
	},
	},
	},
	}
	```

	#### Header personalizzati

	Helicone supporta header personalizzati per funzionalità come caching, user tracking e gestione sessioni. Aggiungili alla configurazione del provider usando `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",
	},
	},
	},
	},
	}
	```

	##### Tracciamento sessioni

	La funzionalità [Sessions](https://docs.helicone.ai/features/sessions) di Helicone ti permette di raggruppare richieste LLM correlate. Usa il plugin [opencode-helicone-session](https://github.com/H2Shami/opencode-helicone-session) per loggare automaticamente ogni conversazione di OpenCode come una sessione in Helicone.

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

	Aggiungilo alla tua configurazione.

	```json title="opencode.json"
	{
	"plugin": ["opencode-helicone-session"]
	}
	```

	Il plugin inietta gli header `Helicone-Session-Id` e `Helicone-Session-Name` nelle tue richieste. Nella pagina Sessions di Helicone, vedrai ogni conversazione di OpenCode elencata come sessione separata.

	##### Header Helicone comuni

	\| Header \| Descrizione \|
	\| -------------------------- \| -------------------------------------------------------------------------- \|
	\| `Helicone-Cache-Enabled` \| Abilita response caching (`true`/`false`) \|
	\| `Helicone-User-Id` \| Traccia metriche per utente \|
	\| `Helicone-Property-[Name]` \| Aggiungi proprietà personalizzate (ad es. `Helicone-Property-Environment`) \|
	\| `Helicone-Prompt-Id` \| Associa richieste con versioni dei prompt \|

	Vedi la [Helicone Header Directory](https://docs.helicone.ai/helicone-headers/header-directory) per tutti gli header disponibili.

	---

	### llama.cpp

	Puoi configurare opencode per usare modelli locali tramite l'utility llama-server di [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
	}
	}
	}
	}
	}
	}
	```

	In questo esempio:

	- `llama.cpp` è l'ID provider personalizzato. Può essere qualsiasi stringa tu voglia.
	- `npm` specifica il pacchetto da usare per questo provider. Qui, `@ai-sdk/openai-compatible` è usato per qualsiasi API OpenAI-compatible.
	- `name` è il nome visualizzato per il provider nella UI.
	- `options.baseURL` è l'endpoint per il server locale.
	- `models` è una mappa di ID modello e relative configurazioni. Il nome del modello verrà visualizzato nella lista di selezione modelli.

	---

	### IO.NET

	IO.NET offre 17 modelli ottimizzati per vari casi d'uso:

	1. Vai alla [console di IO.NET](https://ai.io.net/), crea un account e genera una chiave API.

	2. Esegui il comando `/connect` e cerca IO.NET.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di IO.NET.

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

	4. Esegui il comando `/models` per selezionare un modello.

	```txt
	/models
	```

	---

	### LM Studio

	Puoi configurare opencode per usare modelli locali tramite 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)"
	}
	}
	}
	}
	}
	```

	In questo esempio:

	- `lmstudio` è l'ID provider personalizzato. Può essere qualsiasi stringa tu voglia.
	- `npm` specifica il pacchetto da usare per questo provider. Qui, `@ai-sdk/openai-compatible` è usato per qualsiasi API OpenAI-compatible.
	- `name` è il nome visualizzato per il provider nella UI.
	- `options.baseURL` è l'endpoint per il server locale.
	- `models` è una mappa di ID modello e relative configurazioni. Il nome del modello verrà visualizzato nella lista di selezione modelli.

	---

	### Moonshot AI

	Per usare Kimi K2 di Moonshot AI:

	1. Vai alla [console di Moonshot AI](https://platform.moonshot.ai/console), crea un account e clicca Create API key.

	2. Esegui il comando `/connect` e cerca Moonshot AI.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di Moonshot.

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

	4. Esegui il comando `/models` per selezionare _Kimi K2_.

	```txt
	/models
	```

	---

	### MiniMax

	1. Vai alla [MiniMax API Console](https://platform.minimax.io/login), crea un account e genera una chiave API.

	2. Esegui il comando `/connect` e cerca MiniMax.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di MiniMax.

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

	4. Esegui il comando `/models` per selezionare un modello come _M2.1_.

	```txt
	/models
	```

	---

	### Nebius Token Factory

	1. Vai alla [console di Nebius Token Factory](https://tokenfactory.nebius.com/), crea un account e clicca Add Key.

	2. Esegui il comando `/connect` e cerca Nebius Token Factory.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di Nebius Token Factory.

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

	4. Esegui il comando `/models` per selezionare un modello come _Kimi K2 Instruct_.

	```txt
	/models
	```

	---

	### Ollama

	Puoi configurare opencode per usare modelli locali tramite Ollama.

	:::tip
	Ollama può auto-configurarsi per OpenCode. Vedi la [documentazione di integrazione Ollama](https://docs.ollama.com/integrations/opencode) per dettagli.
	:::

	```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"
	}
	}
	}
	}
	}
	```

	In questo esempio:

	- `ollama` è l'ID provider personalizzato. Può essere qualsiasi stringa tu voglia.
	- `npm` specifica il pacchetto da usare per questo provider. Qui, `@ai-sdk/openai-compatible` è usato per qualsiasi API OpenAI-compatible.
	- `name` è il nome visualizzato per il provider nella UI.
	- `options.baseURL` è l'endpoint per il server locale.
	- `models` è una mappa di ID modello e relative configurazioni. Il nome del modello verrà visualizzato nella lista di selezione modelli.

	:::tip
	Se le chiamate agli strumenti non funzionano, prova ad aumentare `num_ctx` in Ollama. Inizia da circa 16k - 32k.
	:::

	---

	### Ollama Cloud

	Per usare Ollama Cloud con OpenCode:

	1. Vai su [https://ollama.com/](https://ollama.com/) e accedi o crea un account.

	2. Naviga in Settings > Keys e clicca Add API Key per generare una nuova chiave API.

	3. Copia la chiave API da usare in OpenCode.

	4. Esegui il comando `/connect` e cerca Ollama Cloud.

	```txt
	/connect
	```

	5. Inserisci la tua chiave API di Ollama Cloud.

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

	6. Importante: Prima di usare modelli cloud in OpenCode, devi scaricare le informazioni del modello localmente:

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

	7. Esegui il comando `/models` per selezionare il tuo modello Ollama Cloud.

	```txt
	/models
	```

	---

	### OpenAI

	Consigliamo di iscriversi a [ChatGPT Plus o Pro](https://chatgpt.com/pricing).

	1. Una volta iscritto, esegui il comando `/connect` e seleziona OpenAI.

	```txt
	/connect
	```

	2. Qui puoi selezionare l'opzione ChatGPT Plus/Pro: aprirà il tuo browser
	e ti chiederà di autenticarti.

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

	3. Ora tutti i modelli OpenAI dovrebbero essere disponibili quando usi il comando `/models`.

	```txt
	/models
	```

	##### Usare chiavi API

	Se hai già una chiave API, puoi selezionare Manually enter API Key e incollarla nel terminale.

	---

	### OpenCode Zen

	OpenCode Zen è una lista di modelli testati e verificati forniti dal team OpenCode. [Scopri di più](/docs/zen).

	1. Accedi a <a href={console}>OpenCode Zen</a> e clicca Create API Key.

	2. Esegui il comando `/connect` e cerca OpenCode Zen.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di OpenCode.

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

	4. Esegui il comando `/models` per selezionare un modello come _Qwen 3 Coder 480B_.

	```txt
	/models
	```

	---

	### OpenRouter

	1. Vai alla [dashboard di OpenRouter](https://openrouter.ai/settings/keys), clicca Create API Key e copia la chiave.

	2. Esegui il comando `/connect` e cerca OpenRouter.

	```txt
	/connect
	```

	3. Inserisci la chiave API per il provider.

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

	4. Molti modelli OpenRouter sono precaricati di default, esegui il comando `/models` per selezionare quello che vuoi.

	```txt
	/models
	```

	Puoi anche aggiungere modelli addizionali tramite la tua configurazione di opencode.

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

	5. Puoi anche personalizzarli tramite la configurazione di opencode. Ecco un esempio di specifica di un provider

	```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 fornisce accesso a oltre 40 modelli di OpenAI, Anthropic, Google, Amazon, Meta, Mistral e AI21 tramite una piattaforma unificata.

	1. Vai al tuo [SAP BTP Cockpit](https://account.hana.ondemand.com/), naviga nella tua istanza di servizio SAP AI Core e crea una service key.

	:::tip
	La service key è un oggetto JSON contenente `clientid`, `clientsecret`, `url` e `serviceurls.AI_API_URL`. Puoi trovare la tua istanza AI Core sotto Services > Instances and Subscriptions nel BTP Cockpit.
	:::

	2. Esegui il comando `/connect` e cerca SAP AI Core.

	```txt
	/connect
	```

	3. Inserisci il JSON della tua service key.

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

	Oppure imposta la variabile d'ambiente `AICORE_SERVICE_KEY`:

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

	Oppure aggiungila al tuo profilo bash:

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

	4. Facoltativamente imposta deployment ID e resource group:

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

	:::note
	Queste impostazioni sono opzionali e dovrebbero essere configurate in base al tuo setup SAP AI Core.
	:::

	5. Esegui il comando `/models` per selezionare tra gli oltre 40 modelli disponibili.

	```txt
	/models
	```

	---

	### STACKIT

	STACKIT AI Model Serving fornisce un ambiente di hosting completamente gestito e sovrano per modelli AI, concentrandosi su LLM come Llama, Mistral e Qwen, con la massima sovranità dei dati su infrastruttura europea.

	1. Vai al [Portale STACKIT](https://portal.stackit.cloud), naviga in AI Model Serving e crea un token di autenticazione per il tuo progetto.

	:::tip
	Devi avere un account cliente STACKIT, un account utente e un progetto prima di creare token di autenticazione.
	:::

	2. Esegui il comando `/connect` e cerca STACKIT.

	```txt
	/connect
	```

	3. Inserisci il tuo token di autenticazione STACKIT AI Model Serving.

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

	4. Esegui il comando `/models` per selezionare tra i modelli disponibili come _Qwen3-VL 235B_ o _Llama 3.3 70B_.

	```txt
	/models
	```

	---

	### OVHcloud AI Endpoints

	1. Vai al [pannello OVHcloud](https://ovh.com/manager). Naviga nella sezione `Public Cloud`, `AI & Machine Learning` > `AI Endpoints` e nella scheda `API Keys`, clicca Create a new API key.

	2. Esegui il comando `/connect` e cerca OVHcloud AI Endpoints.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di OVHcloud AI Endpoints.

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

	4. Esegui il comando `/models` per selezionare un modello come _gpt-oss-120b_.

	```txt
	/models
	```

	---

	### Scaleway

	Per usare le [Scaleway Generative APIs](https://www.scaleway.com/en/docs/generative-apis/) con Opencode:

	1. Vai alle [impostazioni IAM della Console Scaleway](https://console.scaleway.com/iam/api-keys) per generare una nuova chiave API.

	2. Esegui il comando `/connect` e cerca Scaleway.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di Scaleway.

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

	4. Esegui il comando `/models` per selezionare un modello come _devstral-2-123b-instruct-2512_ o _gpt-oss-120b_.

	```txt
	/models
	```

	---

	### Together AI

	1. Vai alla [console di Together AI](https://api.together.ai), crea un account e clicca Add Key.

	2. Esegui il comando `/connect` e cerca Together AI.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di Together AI.

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

	4. Esegui il comando `/models` per selezionare un modello come _Kimi K2 Instruct_.

	```txt
	/models
	```

	---

	### Venice AI

	1. Vai alla [console di Venice AI](https://venice.ai), crea un account e genera una chiave API.

	2. Esegui il comando `/connect` e cerca Venice AI.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di Venice AI.

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

	4. Esegui il comando `/models` per selezionare un modello come _Llama 3.3 70B_.

	```txt
	/models
	```

	---

	### Vercel AI Gateway

	Vercel AI Gateway ti permette di accedere a modelli di OpenAI, Anthropic, Google, xAI e altri tramite un endpoint unificato. I modelli sono offerti al prezzo di listino senza ricarichi.

	1. Vai alla [dashboard Vercel](https://vercel.com/), naviga nella scheda AI Gateway e clicca API keys per creare una nuova chiave API.

	2. Esegui il comando `/connect` e cerca Vercel AI Gateway.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di Vercel AI Gateway.

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

	4. Esegui il comando `/models` per selezionare un modello.

	```txt
	/models
	```

	Puoi anche personalizzare i modelli tramite la tua configurazione di opencode. Ecco un esempio di come specificare l'ordine di routing dei provider.

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

	Alcune opzioni di routing utili:

	\| Opzione \| Descrizione \|
	\| ------------------- \| --------------------------------------------------- \|
	\| `order` \| Sequenza di provider da provare \|
	\| `only` \| Restringi a provider specifici \|
	\| `zeroDataRetention` \| Usa solo provider con policy di zero data retention \|

	---

	### xAI

	1. Vai alla [console di xAI](https://console.x.ai/), crea un account e genera una chiave API.

	2. Esegui il comando `/connect` e cerca xAI.

	```txt
	/connect
	```

	3. Inserisci la tua chiave API di xAI.

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

	4. Esegui il comando `/models` per selezionare un modello come _Grok Beta_.

	```txt
	/models
	```

	---

	### Z.AI

	1. Vai alla [console API di Z.AI](https://z.ai/manage-apikey/apikey-list), crea un account e clicca Create a new API key.

	2. Esegui il comando `/connect` e cerca Z.AI.

	```txt
	/connect
	```

	Se sei iscritto al GLM Coding Plan, seleziona Z.AI Coding Plan.

	3. Inserisci la tua chiave API di Z.AI.

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

	4. Esegui il comando `/models` per selezionare un modello come _GLM-4.7_.

	```txt
	/models
	```

	---

	### ZenMux

	1. Vai alla [dashboard di ZenMux](https://zenmux.ai/settings/keys), clicca Create API Key e copia la chiave.

	2. Esegui il comando `/connect` e cerca ZenMux.

	```txt
	/connect
	```

	3. Inserisci la chiave API per il provider.

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

	4. Molti modelli ZenMux sono precaricati di default, esegui il comando `/models` per selezionare quello che vuoi.

	```txt
	/models
	```

	Puoi anche aggiungere modelli addizionali tramite la tua configurazione di opencode.

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

	---

	## Provider personalizzato

	Per aggiungere qualsiasi provider OpenAI-compatible non elencato nel comando `/connect`:

	:::tip
	Puoi usare qualsiasi provider OpenAI-compatible con opencode. La maggior parte dei provider AI moderni offre API OpenAI-compatible.
	:::

	1. Esegui il comando `/connect` e scorri fino a Other.

	```bash
	$ /connect

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

	2. Inserisci un ID univoco per il provider.

	```bash
	$ /connect

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

	:::note
	Scegli un ID facile da ricordare, lo userai nel tuo file di configurazione.
	:::

	3. Inserisci la tua chiave API per il provider.

	```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. Crea o aggiorna il tuo file `opencode.json` nella directory del progetto:

	```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"
	}
	}
	}
	}
	}
	```

	Ecco le opzioni di configurazione:
	- npm: Pacchetto AI SDK da usare, `@ai-sdk/openai-compatible` per provider OpenAI-compatible
	- name: Nome visualizzato nella UI.
	- models: Modelli disponibili.
	- options.baseURL: URL dell'endpoint API.
	- options.apiKey: Opzionalmente imposta la chiave API, se non usi auth.
	- options.headers: Opzionalmente imposta header personalizzati.

	Maggiori dettagli sulle opzioni avanzate nell'esempio sotto.

	5. Esegui il comando `/models`: il tuo provider personalizzato e i modelli appariranno nella lista di selezione.

	---

	##### Esempio

	Ecco un esempio che imposta le opzioni `apiKey`, `headers` e `limit` del modello.

	```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
	}
	}
	}
	}
	}
	}
	```

	Dettagli configurazione:

	- apiKey: Imposta usando la sintassi variabile `env`, [scopri di più](/docs/config#env-vars).
	- headers: Header personalizzati inviati con ogni richiesta.
	- limit.context: Massimi token di input accettati dal modello.
	- limit.output: Massimi token che il modello può generare.

	I campi `limit` permettono a OpenCode di capire quanto contesto rimane. I provider standard recuperano questi dati da models.dev automaticamente.

	---

	## Risoluzione dei problemi

	Se hai problemi con la configurazione di un provider, controlla quanto segue:

	1. Controlla il setup auth: Esegui `opencode auth list` per vedere se le credenziali
	per il provider sono aggiunte alla tua configurazione.

	Questo non si applica a provider come Amazon Bedrock, che si basano su variabili d'ambiente per l'autenticazione.

	2. Per provider personalizzati, controlla la config di opencode e:
	- Assicurati che l'ID provider usato nel comando `/connect` corrisponda all'ID nella tua config opencode.
	- Che sia usato il pacchetto npm corretto per il provider. Per esempio, usa `@ai-sdk/cerebras` per Cerebras. E per tutti gli altri provider OpenAI-compatible, usa `@ai-sdk/openai-compatible`.
	- Controlla che sia usato l'endpoint API corretto nel campo `options.baseURL`.

Xet Storage Details

Size:: 47.4 kB
Xet hash:: c546b17a6e3eba2b24bf7eec3e96943fc4be48ee7b5ad56bc1d680d2953fdfe4

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.