Providers

Usa qualsiasi provider LLM in OpenCode.

OpenCode usa AI SDK e Models.dev per supportare oltre 75 provider LLM e anche modelli locali.

Per aggiungere un provider devi:

Aggiungere le API key del provider con il comando /connect.
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.

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

Esegui /connect nella TUI, seleziona opencode e vai su opencode.ai/auth.
```
/connect
```
Accedi, aggiungi i dati di fatturazione e copia la tua API key.
Incolla la tua API key.
```
┌ API key
│
│
└ enter
```
Esegui /models nella TUI per vedere la lista di modelli consigliati.
```
/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.

302.AI

Vai alla console di 302.AI, crea un account e genera una chiave API.
Esegui il comando /connect e cerca 302.AI.
```
/connect
```
Inserisci la tua chiave API di 302.AI.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello.
```
/models
```

Amazon Bedrock

Per usare Amazon Bedrock con OpenCode:

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

Devi avere accesso al modello che vuoi in Amazon Bedrock.
Configura l’autenticazione usando uno dei seguenti metodi:

Variabili d’ambiente (Avvio rapido)

Imposta una di queste variabili d’ambiente mentre esegui opencode:
Terminal window
```
# Option 1: Using AWS access keys
AWS_ACCESS_KEY_ID=XXX AWS_SECRET_ACCESS_KEY=YYY opencode

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

# Option 3: Using Bedrock bearer token
AWS_BEARER_TOKEN_BEDROCK=XXX opencode
```
Oppure aggiungile al tuo profilo bash:
~/.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:
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)
Le opzioni del file di configurazione hanno la precedenza sulle variabili d’ambiente.

Avanzato: VPC Endpoints

Se stai usando VPC endpoints per Bedrock:
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "amazon-bedrock": {
      "options": {
        "region": "us-east-1",
        "profile": "production",
        "endpoint": "https://bedrock-runtime.us-east-1.vpce-xxxxx.amazonaws.com"
      }
    }
  }
}
```
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
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.
Esegui il comando /models per selezionare il modello che vuoi.
```
/models
```

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:

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

Una volta registrato, esegui il comando /connect e seleziona Anthropic.
```
/connect
```
Qui puoi selezionare l’opzione Claude Pro/Max: aprirà il tuo browser e ti chiederà di autenticarti.
```
┌ Select auth method
│
│ Claude Pro/Max
│ Create an API Key
│ Manually enter API Key
└
```
Ora tutti i modelli Anthropic dovrebbero essere disponibili quando usi il comando /models.
```
/models
```

L’uso dell’abbonamento Claude Pro/Max in OpenCode non è ufficialmente supportato da Anthropic.

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.

Azure OpenAI

Vai al portale Azure 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
Vai su Azure AI Foundry e fai il deploy di un modello.

Il nome del deployment deve corrispondere al nome del modello affinché opencode funzioni correttamente.
Esegui il comando /connect e cerca Azure.
```
/connect
```
Inserisci la tua chiave API.
```
┌ API key
│
│
└ enter
```
Imposta il nome della risorsa come variabile d’ambiente:
Terminal window
```
AZURE_RESOURCE_NAME=XXX opencode
```
Oppure aggiungilo al tuo profilo bash:
~/.bash_profile
```
export AZURE_RESOURCE_NAME=XXX
```
Esegui il comando /models per selezionare il tuo modello deployato.
```
/models
```

Azure Cognitive Services

Vai al portale Azure 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
Vai su Azure AI Foundry e fai il deploy di un modello.

Il nome del deployment deve corrispondere al nome del modello affinché opencode funzioni correttamente.
Esegui il comando /connect e cerca Azure Cognitive Services.
```
/connect
```
Inserisci la tua chiave API.
```
┌ API key
│
│
└ enter
```
Imposta il nome della risorsa come variabile d’ambiente:
Terminal window
```
AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
```
Oppure aggiungilo al tuo profilo bash:
~/.bash_profile
```
export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX
```
Esegui il comando /models per selezionare il tuo modello deployato.
```
/models
```

Baseten

Vai su Baseten, crea un account e genera una chiave API.
Esegui il comando /connect e cerca Baseten.
```
/connect
```
Inserisci la tua chiave API di Baseten.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello.
```
/models
```

Cerebras

Vai alla console di Cerebras, crea un account e genera una chiave API.
Esegui il comando /connect e cerca Cerebras.
```
/connect
```
Inserisci la tua chiave API di Cerebras.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello come Qwen 3 Coder 480B.
```
/models
```

Cloudflare AI Gateway ti permette di accedere a modelli di OpenAI, Anthropic, Workers AI e altri tramite un endpoint unificato. Con la fatturazione unificata non hai bisogno di chiavi API separate per ogni provider.

Vai alla dashboard di Cloudflare, naviga in AI > AI Gateway e crea un nuovo gateway.

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

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

Esegui il comando /connect e cerca Cloudflare AI Gateway.
```
/connect
```
Inserisci il tuo API token di Cloudflare.
```
┌ API key
│
│
└ enter
```
Oppure impostalo come variabile d’ambiente.
~/.bash_profile
```
export CLOUDFLARE_API_TOKEN=your-api-token
```

Esegui il comando /models per selezionare un modello.

/models

Puoi anche aggiungere modelli tramite la tua configurazione di opencode.

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

Cortecs

Vai alla console di Cortecs, crea un account e genera una chiave API.
Esegui il comando /connect e cerca Cortecs.
```
/connect
```
Inserisci la tua chiave API di Cortecs.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello come Kimi K2 Instruct.
```
/models
```

DeepSeek

Vai alla console di DeepSeek, crea un account e clicca Create new API key.
Esegui il comando /connect e cerca DeepSeek.
```
/connect
```
Inserisci la tua chiave API di DeepSeek.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello DeepSeek come DeepSeek Reasoner.
```
/models
```

Deep Infra

Vai alla dashboard di Deep Infra, crea un account e genera una chiave API.
Esegui il comando /connect e cerca Deep Infra.
```
/connect
```
Inserisci la tua chiave API di Deep Infra.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello.
```
/models
```

Firmware

Vai alla dashboard di Firmware, crea un account e genera una chiave API.
Esegui il comando /connect e cerca Firmware.
```
/connect
```
Inserisci la tua chiave API di Firmware.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello.
```
/models
```

Fireworks AI

Vai alla console di Fireworks AI, crea un account e clicca Create API Key.
Esegui il comando /connect e cerca Fireworks AI.
```
/connect
```
Inserisci la tua chiave API di Fireworks AI.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello come Kimi K2 Instruct.
```
/models
```

GitLab Duo

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

Esegui il comando /connect e seleziona GitLab.
```
/connect
```
Scegli il tuo metodo di autenticazione:
```
┌ 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
2. Clicca Add new token
3. Nome: OpenCode, Scopes: api
4. Copia il token (inizia con glpat-)
5. Inseriscilo nel terminale
Esegui il comando /models per vedere i modelli disponibili.
```
/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

GitLab Self-Hosted

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.

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

Per istanze GitLab self-hosted:

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

Se la tua istanza esegue un AI Gateway personalizzato:

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

Oppure aggiungi al tuo profilo bash:

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

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:

export GITLAB_OAUTH_CLIENT_ID=your_application_id_here

Maggior documentazione sulla homepage di opencode-gitlab-auth.

Configurazione

Personalizza tramite opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "gitlab": {
      "options": {
        "instanceUrl": "https://gitlab.com",
        "featureFlags": {
          "duo_agent_platform_agentic_chat": true,
          "duo_agent_platform": true
        }
      }
    }
  }
}

Strumenti API GitLab (Opzionale, ma altamente raccomandato)

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

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

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

Vai su github.com/login/device e inserisci il codice.

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

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

Google Vertex AI

Per usare Google Vertex AI con OpenCode:

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

Devi avere un progetto Google Cloud con l’API Vertex AI abilitata.
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.
Terminal window
```
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id opencode
```
Oppure aggiungile al tuo profilo bash.
~/.bash_profile
```
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
export GOOGLE_CLOUD_PROJECT=your-project-id
export VERTEX_LOCATION=global
```

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

Groq

Vai alla console di Groq, clicca Create API Key e copia la chiave.
Esegui il comando /connect e cerca Groq.
```
/connect
```
Inserisci la chiave API per il provider.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare quello che vuoi.
```
/models
```

Hugging Face

Hugging Face Inference Providers fornisce accesso a modelli open supportati da 17+ provider.

Vai alle impostazioni di Hugging Face per creare un token con il permesso di effettuare chiamate agli Inference Providers.
Esegui il comando /connect e cerca Hugging Face.
```
/connect
```
Inserisci il tuo token Hugging Face.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello come Kimi-K2-Instruct o GLM-4.6.
```
/models
```

Helicone

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

Vai su Helicone, crea un account e genera una chiave API dalla tua dashboard.
Esegui il comando /connect e cerca Helicone.
```
/connect
```
Inserisci la tua chiave API di Helicone.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello.
```
/models
```

Per altri provider e funzionalità avanzate come caching e rate limiting, controlla la documentazione di Helicone.

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, ti servirà per recuperare gli ID dei modelli che vuoi aggiungere.

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

{
  "$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 di Helicone ti permette di raggruppare richieste LLM correlate. Usa il plugin opencode-helicone-session per loggare automaticamente ogni conversazione di OpenCode come una sessione in Helicone.

npm install -g opencode-helicone-session

Aggiungilo alla tua configurazione.

{
  "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 per tutti gli header disponibili.

llama.cpp

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

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:

Vai alla console di IO.NET, crea un account e genera una chiave API.
Esegui il comando /connect e cerca IO.NET.
```
/connect
```
Inserisci la tua chiave API di IO.NET.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello.
```
/models
```

LM Studio

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

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:

Vai alla console di Moonshot AI, crea un account e clicca Create API key.
Esegui il comando /connect e cerca Moonshot AI.
```
/connect
```
Inserisci la tua chiave API di Moonshot.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare Kimi K2.
```
/models
```

MiniMax

Vai alla MiniMax API Console, crea un account e genera una chiave API.
Esegui il comando /connect e cerca MiniMax.
```
/connect
```
Inserisci la tua chiave API di MiniMax.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello come M2.1.
```
/models
```

Nebius Token Factory

Vai alla console di Nebius Token Factory, crea un account e clicca Add Key.
Esegui il comando /connect e cerca Nebius Token Factory.
```
/connect
```
Inserisci la tua chiave API di Nebius Token Factory.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello come Kimi K2 Instruct.
```
/models
```

Ollama

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

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.

Ollama Cloud

Per usare Ollama Cloud con OpenCode:

Vai su https://ollama.com/ e accedi o crea un account.
Naviga in Settings > Keys e clicca Add API Key per generare una nuova chiave API.
Copia la chiave API da usare in OpenCode.
Esegui il comando /connect e cerca Ollama Cloud.
```
/connect
```
Inserisci la tua chiave API di Ollama Cloud.
```
┌ API key
│
│
└ enter
```
Importante: Prima di usare modelli cloud in OpenCode, devi scaricare le informazioni del modello localmente:
Terminal window
```
ollama pull gpt-oss:20b-cloud
```
Esegui il comando /models per selezionare il tuo modello Ollama Cloud.
```
/models
```

OpenAI

Consigliamo di iscriversi a ChatGPT Plus o Pro.

Una volta iscritto, esegui il comando /connect e seleziona OpenAI.
```
/connect
```
Qui puoi selezionare l’opzione ChatGPT Plus/Pro: aprirà il tuo browser e ti chiederà di autenticarti.
```
┌ Select auth method
│
│ ChatGPT Plus/Pro
│ Manually enter API Key
└
```
Ora tutti i modelli OpenAI dovrebbero essere disponibili quando usi il comando /models.
```
/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ù.

Accedi a OpenCode Zen e clicca Create API Key.
Esegui il comando /connect e cerca OpenCode Zen.
```
/connect
```
Inserisci la tua chiave API di OpenCode.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello come Qwen 3 Coder 480B.
```
/models
```

OpenRouter

Vai alla dashboard di OpenRouter, clicca Create API Key e copia la chiave.
Esegui il comando /connect e cerca OpenRouter.
```
/connect
```
Inserisci la chiave API per il provider.
```
┌ API key
│
│
└ enter
```
Molti modelli OpenRouter sono precaricati di default, esegui il comando /models per selezionare quello che vuoi.
```
/models
```
Puoi anche aggiungere modelli addizionali tramite la tua configurazione di opencode.
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openrouter": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}
```

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

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

Vai al tuo SAP BTP Cockpit, naviga nella tua istanza di servizio SAP AI Core e crea una service key.

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.
Esegui il comando /connect e cerca SAP AI Core.
```
/connect
```

Inserisci il JSON della tua service key.

┌ Service key
│
│
└ enter

Oppure imposta la variabile d’ambiente AICORE_SERVICE_KEY:

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

Oppure aggiungila al tuo profilo bash:

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

Facoltativamente imposta deployment ID e resource group:
Terminal window
```
AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode
```
Queste impostazioni sono opzionali e dovrebbero essere configurate in base al tuo setup SAP AI Core.
Esegui il comando /models per selezionare tra gli oltre 40 modelli disponibili.
```
/models
```

OVHcloud AI Endpoints

Vai al pannello OVHcloud. Naviga nella sezione Public Cloud, AI & Machine Learning > AI Endpoints e nella scheda API Keys, clicca Create a new API key.
Esegui il comando /connect e cerca OVHcloud AI Endpoints.
```
/connect
```
Inserisci la tua chiave API di OVHcloud AI Endpoints.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello come gpt-oss-120b.
```
/models
```

Scaleway

Per usare le Scaleway Generative APIs con Opencode:

Vai alle impostazioni IAM della Console Scaleway per generare una nuova chiave API.
Esegui il comando /connect e cerca Scaleway.
```
/connect
```
Inserisci la tua chiave API di Scaleway.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello come devstral-2-123b-instruct-2512 o gpt-oss-120b.
```
/models
```

Together AI

Vai alla console di Together AI, crea un account e clicca Add Key.
Esegui il comando /connect e cerca Together AI.
```
/connect
```
Inserisci la tua chiave API di Together AI.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello come Kimi K2 Instruct.
```
/models
```

Venice AI

Vai alla console di Venice AI, crea un account e genera una chiave API.
Esegui il comando /connect e cerca Venice AI.
```
/connect
```
Inserisci la tua chiave API di Venice AI.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello come Llama 3.3 70B.
```
/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.

Vai alla dashboard Vercel, naviga nella scheda AI Gateway e clicca API keys per creare una nuova chiave API.
Esegui il comando /connect e cerca Vercel AI Gateway.
```
/connect
```
Inserisci la tua chiave API di Vercel AI Gateway.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello.
```
/models
```

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

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

Vai alla console di xAI, crea un account e genera una chiave API.
Esegui il comando /connect e cerca xAI.
```
/connect
```
Inserisci la tua chiave API di xAI.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello come Grok Beta.
```
/models
```

Z.AI

Vai alla console API di Z.AI, crea un account e clicca Create a new API key.
Esegui il comando /connect e cerca Z.AI.
```
/connect
```
Se sei iscritto al GLM Coding Plan, seleziona Z.AI Coding Plan.
Inserisci la tua chiave API di Z.AI.
```
┌ API key
│
│
└ enter
```
Esegui il comando /models per selezionare un modello come GLM-4.7.
```
/models
```

ZenMux

Vai alla dashboard di ZenMux, clicca Create API Key e copia la chiave.
Esegui il comando /connect e cerca ZenMux.
```
/connect
```
Inserisci la chiave API per il provider.
```
┌ API key
│
│
└ enter
```
Molti modelli ZenMux sono precaricati di default, esegui il comando /models per selezionare quello che vuoi.
```
/models
```
Puoi anche aggiungere modelli addizionali tramite la tua configurazione di opencode.
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "zenmux": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}
```

Provider personalizzato

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

Esegui il comando /connect e scorri fino a Other.

$ /connect

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

Inserisci un ID univoco per il provider.
Terminal window
```
$ /connect

┌  Add credential
│
◇  Enter provider id
│  myprovider
└
```
Scegli un ID facile da ricordare, lo userai nel tuo file di configurazione.

Inserisci la tua chiave API per il provider.

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

Crea o aggiorna il tuo file opencode.json nella directory del progetto:
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "myprovider": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "My AI ProviderDisplay Name",
      "options": {
        "baseURL": "https://api.myprovider.com/v1"
      },
      "models": {
        "my-model-name": {
          "name": "My Model Display Name"
        }
      }
    }
  }
}
```
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.
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.

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

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