--- 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": { "": { "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 ``` --- ### Firmware 1. Vai alla [dashboard di Firmware](https://app.firmware.ai/signup), crea un account e genera una chiave API. 2. Esegui il comando `/connect` e cerca **Firmware**. ```txt /connect ``` 3. Inserisci la tua chiave API di Firmware. ```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 **OpenCode Zen** 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`.