Salta ai contenuti
OpenCode
HomeDocs

Provider

Utilizzo di qualsiasi provider LLM in OpenCode.

OpenCode utilizza l’AI SDK e Models.dev per supportare pi di 75 provider LLM e supporta l’esecuzione di modelli locali.

Per aggiungere un provider, devi:

  1. Aggiungere le chiavi API del provider utilizzando il comando /connect.
  2. Configurare il provider nella tua configurazione OpenCode.

Credenziali

Quando aggiungi le chiavi API di un provider con il comando /connect, vengono memorizzate in ~/.local/share/opencode/auth.json.

Configurazione

Puoi personalizzare i provider tramite la sezione provider nella tua configurazione OpenCode.

URL di base

Puoi personalizzare l’URL di base per qualsiasi provider impostando l’opzione baseURL. Ci utile quando si utilizzano servizi proxy o endpoint personalizzati.

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

OpenCode Zen

OpenCode Zen un elenco di modelli forniti dal team OpenCode che sono stati testati e verificati per funzionare bene con OpenCode. Ulteriori informazioni.

  1. Esegui il comando /connect nel TUI, seleziona opencode e vai a opencode.ai/auth.

    /connect

  2. Accedi, aggiungi i dettagli di fatturazione e copia la tua chiave API.

  3. Incolla la tua chiave API.

    ┌ API key
    │
    │
    └ enter

  4. Esegui /models nel TUI per vedere l’elenco dei modelli che raccomandiamo.

    /models

Funziona come qualsiasi altro provider in OpenCode. Il suo utilizzo completamente facoltativo.

Directory

Esaminiamo in dettaglio alcuni dei provider. Se desideri aggiungere un provider all’elenco, non esitare ad aprire una PR.

Amazon Bedrock

Per utilizzare Amazon Bedrock con OpenCode:

  1. Vai al Catalogo modelli nella console Amazon Bedrock e richiedi l’accesso ai modelli che desideri.

  2. Configura l’autenticazione utilizzando uno dei seguenti metodi:

    Variabili d’ambiente (Avvio rapido)

    Imposta una di queste variabili d’ambiente durante l’esecuzione di opencode:

    Terminal window
    # Opzione 1: Utilizzo delle chiavi di accesso AWS
    AWS_ACCESS_KEY_ID=XXX AWS_SECRET_ACCESS_KEY=YYY opencode
    

    # Opzione 2: Utilizzo di un profilo AWS denominato
    AWS_PROFILE=my-profile opencode
    

    # Opzione 3: Utilizzo del token bearer Bedrock
    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 la 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 esempio, us-east-1, eu-west-1)
    • profile - Profilo AWS denominato da ~/.aws/credentials
    • endpoint - URL endpoint personalizzato per endpoint VPC (alias per l’opzione generica baseURL)

    Avanzato: Endpoint VPC

    Se stai utilizzando endpoint VPC 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"
          }
        }
      }
    }

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

    Priorit di autenticazione

    Amazon Bedrock utilizza la seguente priorit di autenticazione:

    1. Token Bearer - Variabile d’ambiente AWS_BEARER_TOKEN_BEDROCK o token dal comando /connect
    2. Catena di credenziali AWS - Profilo, chiavi di accesso, credenziali condivise, ruoli IAM, metadati istanza

  3. Esegui il comando /models per selezionare il modello che desideri.

    /models

Anthropic

Consigliamo di iscriversi a Claude Pro o Max.

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

    /connect

  2. Qui puoi selezionare l’opzione Claude Pro/Max e aprir il tuo browser e chiederti di autenticarti.

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

    /models
Utilizzo delle chiavi API

Puoi anche selezionare Crea una chiave API se non hai un abbonamento Pro/Max. Aprir anche il tuo browser e chiederarti di accedere ad Anthropic e ti dar un codice che puoi incollare nel tuo terminale.

Oppure se hai gi una chiave API, puoi selezionare Inserisci chiave API manualmente e incollarla nel tuo terminale.

Azure OpenAI

  1. Vai al portale Azure e crea una risorsa Azure OpenAI. Ti servir:

    • Nome della risorsa: Diventa parte del tuo endpoint API (https://RESOURCE_NAME.openai.azure.com/)
    • Chiave API: KEY 1 o KEY 2 dalla tua risorsa

  2. Vai a Azure AI Foundry e distribuisci un modello.

  3. Esegui il comando /connect e cerca Azure.

    /connect

  4. Inserisci la tua chiave API.

    ┌ API key
    │
    │
    └ enter

  5. Imposta il nome della tua 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

  6. Esegui il comando /models per selezionare il modello distribuito.

    /models

Azure Cognitive Services

  1. Vai al portale Azure e crea una risorsa Azure OpenAI. Ti servir:

    • Nome della risorsa: Diventa parte del tuo endpoint API (https://AZURE_COGNITIVE_SERVICES_RESOURCE_NAME.cognitiveservices.azure.com/)
    • Chiave API: KEY 1 o KEY 2 dalla tua risorsa

  2. Vai a Azure AI Foundry e distribuisci un modello.

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

    /connect

  4. Inserisci la tua chiave API.

    ┌ API key
    │
    │
    └ enter

  5. Imposta il nome della tua 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

  6. Esegui il comando /models per selezionare il modello distribuito.

    /models

Baseten

  1. Vai a Baseten, crea un account e genera una chiave API.

  2. Esegui il comando /connect e cerca Baseten.

    /connect

  3. Inserisci la tua chiave API Baseten.

    ┌ API key
    │
    │
    └ enter

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

    /models

Cerebras

  1. Vai alla console Cerebras, crea un account e genera una chiave API.

  2. Esegui il comando /connect e cerca Cerebras.

    /connect

  3. Inserisci la tua chiave API Cerebras.

    ┌ API key
    │
    │
    └ enter

  4. Esegui il comando /models per selezionare un modello come Qwen 3 Coder 480B.

    /models

Cloudflare AI Gateway

Cloudflare AI Gateway ti permette di accedere ai modelli di OpenAI, Anthropic, Workers AI e altro attraverso un endpoint unificato. Con Fatturazione unificata non hai bisogno di chiavi API separate per ogni provider.

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

  2. Imposta il tuo ID account e ID gateway come variabili d’ambiente.

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

    /connect

  4. Inserisci il tuo token API Cloudflare.

    ┌ API key
    │
    │
    └ enter

    Oppure impostalo come variabile d’ambiente.

    ~/.bash_profile
    export CLOUDFLARE_API_TOKEN=your-api-token

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

    /models

    Puoi anche aggiungere modelli attraverso la tua configurazione opencode.

    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 Cortecs, crea un account e genera una chiave API.

  2. Esegui il comando /connect e cerca Cortecs.

    /connect

  3. Inserisci la tua chiave API Cortecs.

    ┌ API key
    │
    │
    └ enter

  4. Esegui il comando /models per selezionare un modello come Kimi K2 Instruct.

    /models

DeepSeek

  1. Vai alla console DeepSeek, crea un account e fai clic su Crea nuova chiave API.

  2. Esegui il comando /connect e cerca DeepSeek.

    /connect

  3. Inserisci la tua chiave API DeepSeek.

    ┌ API key
    │
    │
    └ enter

  4. Esegui il comando /models per selezionare un modello DeepSeek come DeepSeek Reasoner.

    /models

Deep Infra

  1. Vai alla dashboard Deep Infra, crea un account e genera una chiave API.

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

    /connect

  3. Inserisci la tua chiave API Deep Infra.

    ┌ API key
    │
    │
    └ enter

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

    /models

Fireworks AI

  1. Vai alla console Fireworks AI, crea un account e fai clic su Crea chiave API.

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

    /connect

  3. Inserisci la tua chiave API Fireworks AI.

    ┌ API key
    │
    │
    └ enter

  4. Esegui il comando /models per selezionare un modello come Kimi K2 Instruct.

    /models

GitHub Copilot

Per utilizzare il tuo abbonamento GitHub Copilot con opencode:

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

    /connect

  2. Vai a github.com/login/device e inserisci il codice.

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

    /models

Google Vertex AI

Per utilizzare Google Vertex AI con OpenCode:

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

  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 del file della chiave JSON dell’account di servizio
      • Autenticati usando gcloud CLI: gcloud auth application-default login

    Impostale durante l’esecuzione di 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

  1. Esegui il comando /models per selezionare il modello che desideri.

    /models

Groq

  1. Vai alla console Groq, fai clic su Crea chiave API e copia la chiave.

  2. Esegui il comando /connect e cerca Groq.

    /connect

  3. Inserisci la chiave API del provider.

    ┌ API key
    │
    │
    └ enter

  4. Esegui il comando /models per selezionare quello che desideri.

    /models

Hugging Face

Hugging Face Inference Providers fornisce l’accesso a modelli open source supportati da pi di 17 provider.

  1. Vai alle impostazioni di Hugging Face per creare un token con l’autorizzazione a effettuare chiamate ai provider di inferenza.

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

    /connect

  3. Inserisci il tuo token Hugging Face.

    ┌ API key
    │
    │
    └ enter

  4. 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 registrazione, monitoraggio e analisi per le tue applicazioni AI. Il gateway AI di Helicone instrada le tue richieste al provider appropriato automaticamente in base al modello.

  1. Vai a Helicone, crea un account e genera una chiave API dalla tua dashboard.

  2. Esegui il comando /connect e cerca Helicone.

    /connect

  3. Inserisci la tua chiave API Helicone.

    ┌ API key
    │
    │
    └ enter

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

    /models

Per ulteriori provider e funzionalit avanzate come la memorizzazione nella cache e la limitazione della velocit, consulta la documentazione di Helicone.

Configurazioni opzionali

Nell’eventualit in cui vedi una funzionalit o un modello di Helicone che non configurato automaticamente tramite opencode, puoi sempre configurarlo tu stesso.

Ecco l’Elenco modelli di Helicone, ti servir per ottenere gli ID dei modelli che desideri aggiungere.

~/.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": {
          // ID modello (dalla pagina dell'elenco modelli di Helicone)
          "name": "GPT-4o", // Il tuo nome personalizzato per il modello
        },
        "claude-sonnet-4-20250514": {
          "name": "Claude Sonnet 4",
        },
      },
    },
  },
}

Intestazioni personalizzate

Helicone supporta intestazioni personalizzate per funzionalit come la memorizzazione nella cache, il tracciamento degli utenti e la gestione delle sessioni. Aggiungile alla tua configurazione del provider usando options.headers:

~/.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 delle sessioni

La funzionalit Sessioni di Helicone ti consente di raggruppare richieste LML correlate. Usa il plugin opencode-helicone-session per registrare automaticamente ogni conversazione OpenCode come una sessione in Helicone.

Terminal window
npm install -g opencode-helicone-session

Aggiungilo alla tua configurazione.

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

Il plugin inietta le intestazioni Helicone-Session-Id e Helicone-Session-Name nelle tue richieste. Nella pagina Sessioni di Helicone, vedrai ogni conversazione OpenCode elencata come una sessione separata.

Intestazioni comuni di Helicone
IntestazioneDescrizione
Helicone-Cache-EnabledAbilita la memorizzazione nella cache delle risposte (true/false)
Helicone-User-IdTraccia le metriche per utente
Helicone-Property-[Name]Aggiungi propriet personalizzate (ad esempio, Helicone-Property-Environment)
Helicone-Prompt-IdAssocia le richieste con le versioni dei prompt

Vedi l’Elenco delle intestazioni di Helicone per tutte le intestazioni disponibili.

llama.cpp

Puoi configurare opencode per utilizzare modelli locali attraverso l’utilit llama-server di llama.cpp

opencode.json
{
  "$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 che desideri.
  • npm specifica il pacchetto da utilizzare per questo provider. Qui, @ai-sdk/openai-compatible utilizzato per qualsiasi API compatibile con OpenAI.
  • name il nome visualizzato del provider nell’interfaccia utente.
  • options.baseURL l’endpoint per il server locale.
  • models una mappa di ID modello alle loro configurazioni. Il nome del modello verr visualizzato nell’elenco di selezione dei modelli.

IO.NET

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

  1. Vai alla console IO.NET, crea un account e genera una chiave API.

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

    /connect

  3. Inserisci la tua chiave API IO.NET.

    ┌ API key
    │
    │
    └ enter

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

    /models

LM Studio

Puoi configurare opencode per utilizzare modelli locali attraverso LM Studio.

opencode.json
{
  "$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 che desideri.
  • npm specifica il pacchetto da utilizzare per questo provider. Qui, @ai-sdk/openai-compatible utilizzato per qualsiasi API compatibile con OpenAI.
  • name il nome visualizzato del provider nell’interfaccia utente.
  • options.baseURL l’endpoint per il server locale.
  • models una mappa di ID modello alle loro configurazioni. Il nome del modello verr visualizzato nell’elenco di selezione dei modelli.

Moonshot AI

Per utilizzare Kimi K2 di Moonshot AI:

  1. Vai alla console Moonshot AI, crea un account e fai clic su Crea chiave API.

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

    /connect

  3. Inserisci la tua chiave API Moonshot.

    ┌ API key
    │
    │
    └ enter

  4. Esegui il comando /models per selezionare Kimi K2.

    /models

MiniMax

  1. Vai alla Console API MiniMax, crea un account e genera una chiave API.

  2. Esegui il comando /connect e cerca MiniMax.

    /connect

  3. Inserisci la tua chiave API MiniMax.

    ┌ API key
    │
    │
    └ enter

  4. Esegui il comando /models per selezionare un modello come M2.1.

    /models

Nebius Token Factory

  1. Vai alla console Nebius Token Factory, crea un account e fai clic su Aggiungi chiave.

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

    /connect

  3. Inserisci la tua chiave API Nebius Token Factory.

    ┌ API key
    │
    │
    └ enter

  4. Esegui il comando /models per selezionare un modello come Kimi K2 Instruct.

    /models

Ollama

Puoi configurare opencode per utilizzare modelli locali attraverso Ollama.

opencode.json
{
  "$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 che desideri.
  • npm specifica il pacchetto da utilizzare per questo provider. Qui, @ai-sdk/openai-compatible utilizzato per qualsiasi API compatibile con OpenAI.
  • name il nome visualizzato del provider nell’interfaccia utente.
  • options.baseURL l’endpoint per il server locale.
  • models una mappa di ID modello alle loro configurazioni. Il nome del modello verr visualizzato nell’elenco di selezione dei modelli.

Ollama Cloud

Per utilizzare Ollama Cloud con OpenCode:

  1. Vai a https://ollama.com/ e accedi o crea un account.

  2. Naviga in Impostazioni > Chiavi e fai clic su Aggiungi chiave API per generare una nuova chiave API.

  3. Copia la chiave API per l’uso in OpenCode.

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

    /connect

  5. Inserisci la tua chiave API Ollama Cloud.

    ┌ API key
    │
    │
    └ enter

  6. Importante: Prima di utilizzare i modelli cloud in OpenCode, devi recuperare le informazioni del modello localmente:

    Terminal window
    ollama pull gpt-oss:20b-cloud

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

    /models

OpenAI

Consigliamo di iscriversi a ChatGPT Plus o Pro.

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

    /connect

  2. Qui puoi selezionare l’opzione ChatGPT Plus/Pro e aprir il tuo browser e chiederti di autenticarti.

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

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

    /models
Utilizzo delle chiavi API

Se hai gi una chiave API, puoi selezionare Inserisci chiave API manualmente e incollarla nel tuo terminale.

OpenCode Zen

OpenCode Zen un elenco di modelli testati e verificati forniti dal team OpenCode. Ulteriori informazioni.

  1. Accedi a OpenCode Zen e fai clic su Crea chiave API.

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

    /connect

  3. Inserisci la tua chiave API OpenCode.

    ┌ API key
    │
    │
    └ enter

  4. Esegui il comando /models per selezionare un modello come Qwen 3 Coder 480B.

    /models

OpenRouter

  1. Vai alla dashboard OpenRouter, fai clic su Crea chiave API e copia la chiave.

  2. Esegui il comando /connect e cerca OpenRouter.

    /connect

  3. Inserisci la chiave API del provider.

    ┌ API key
    │
    │
    └ enter

  4. Molti modelli OpenRouter sono precaricati per impostazione predefinita, esegui il comando /models per selezionare quello che desideri.

    /models

    Puoi anche aggiungere modelli aggiuntivi attraverso la tua configurazione opencode.

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

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

    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 l’accesso a pi di 40 modelli di OpenAI, Anthropic, Google, Amazon, Meta, Mistral e AI21 attraverso una piattaforma unificata.

  1. Vai al tuo Cockpit SAP BTP, naviga alla tua istanza del servizio SAP AI Core e crea una chiave di servizio.

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

    /connect

  3. Inserisci la tua chiave di servizio JSON.

    ┌ Service key
    │
    │
    └ enter

    Oppure imposta la variabile d’ambiente AICORE_SERVICE_KEY:

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

    Oppure aggiungila al tuo profilo bash:

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

  4. Facoltativamente, imposta l’ID di distribuzione e il gruppo di risorse:

    Terminal window
    AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode

  5. Esegui il comando /models per selezionare tra pi di 40 modelli disponibili.

    /models

OVHcloud AI Endpoints

  1. Vai al pannello OVHcloud. Naviga nella sezione Public Cloud, AI & Machine Learning > AI Endpoints e nella scheda API Keys, fai clic su Crea una nuova chiave API.

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

    /connect

  3. Inserisci la tua chiave API OVHcloud AI Endpoints.

    ┌ API key
    │
    │
    └ enter

  4. Esegui il comando /models per selezionare un modello come gpt-oss-120b.

    /models

Scaleway

Per utilizzare le API Generative Scaleway con Opencode:

  1. Vai alle impostazioni IAM della console Scaleway per generare una nuova chiave API.

  2. Esegui il comando /connect e cerca Scaleway.

    /connect

  3. Inserisci la tua chiave API Scaleway.

    ┌ API key
    │
    │
    └ enter

  4. Esegui il comando /models per selezionare un modello come devstral-2-123b-instruct-2512 o gpt-oss-120b.

    /models

Together AI

  1. Vai alla console Together AI, crea un account e fai clic su Aggiungi chiave.

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

    /connect

  3. Inserisci la tua chiave API Together AI.

    ┌ API key
    │
    │
    └ enter

  4. Esegui il comando /models per selezionare un modello come Kimi K2 Instruct.

    /models

Venice AI

  1. Vai alla console Venice AI, crea un account e genera una chiave API.

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

    /connect

  3. Inserisci la tua chiave API Venice AI.

    ┌ API key
    │
    │
    └ enter

  4. Esegui il comando /models per selezionare un modello come Llama 3.3 70B.

    /models

Vercel AI Gateway

Vercel AI Gateway ti permette di accedere ai modelli di OpenAI, Anthropic, Google, xAI e altro attraverso un endpoint unificato. I modelli sono offerti al prezzo di listino senza sovrapprezzo.

  1. Vai alla dashboard Vercel, naviga nella scheda AI Gateway e fai clic su Chiavi API per creare una nuova chiave API.

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

    /connect

  3. Inserisci la tua chiave API Vercel AI Gateway.

    ┌ API key
    │
    │
    └ enter

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

    /models

Puoi anche personalizzare i modelli attraverso la tua configurazione opencode. Ecco un esempio di specifica dell’ordine di routing del provider.

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

Alcune opzioni di routing utili:

OpzioneDescrizione
orderSequenza di provider da provare
onlyRestringi a provider specifici
zeroDataRetentionUsa solo provider con politiche di zero conservazione dati

xAI

  1. Vai alla console xAI, crea un account e genera una chiave API.

  2. Esegui il comando /connect e cerca xAI.

    /connect

  3. Inserisci la tua chiave API xAI.

    ┌ API key
    │
    │
    └ enter

  4. Esegui il comando /models per selezionare un modello come Grok Beta.

    /models

Z.AI

  1. Vai alla console API Z.AI, crea un account e fai clic su Crea una nuova chiave API.

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

    /connect

    Se sei iscritto al Piano di codifica GLM, seleziona Piano di codifica Z.AI.

  3. Inserisci la tua chiave API Z.AI.

    ┌ API key
    │
    │
    └ enter

  4. Esegui il comando /models per selezionare un modello come GLM-4.7.

    /models

ZenMux

  1. Vai alla dashboard ZenMux, fai clic su Crea chiave API e copia la chiave.

  2. Esegui il comando /connect e cerca ZenMux.

    /connect

  3. Inserisci la chiave API del provider.

    ┌ API key
    │
    │
    └ enter

  4. Molti modelli ZenMux sono precaricati per impostazione predefinita, esegui il comando /models per selezionare quello che desideri.

    /models

    Puoi anche aggiungere modelli aggiuntivi attraverso la tua configurazione opencode.

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

Provider personalizzato

Per aggiungere qualsiasi provider compatibile con OpenAI che non elencato nel comando /connect:

  1. Esegui il comando /connect e scorri verso il basso su Altro.

    Terminal window
    $ /connect
    

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

  2. Inserisci un ID univoco per il provider.

    Terminal window
    $ /connect
    

    ┌  Add credential
    │
    ◇  Enter provider id
    │  myprovider
    └

  3. Inserisci la tua chiave API per il provider.

    Terminal window
    $ /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 tua 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 compatibili con OpenAI
    • name: Nome visualizzato nell’interfaccia utente.
    • models: Modelli disponibili.
    • options.baseURL: URL endpoint API.
    • options.apiKey: Imposta facoltativamente la chiave API, se non usi l’autenticazione.
    • options.headers: Imposta facoltativamente intestazioni personalizzate.

    Per ulteriori informazioni sulle opzioni avanzate, consulta l’esempio seguente.

  5. Esegui il comando /models e il tuo provider personalizzato e i modelli appariranno nell’elenco di selezione.

Esempio

Ecco un esempio di impostazione delle opzioni apiKey, headers e limit del modello.

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",
        "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 della configurazione:

  • apiKey: Impostato usando la sintassi della variabile env, ulteriori informazioni.
  • headers: Intestazioni personalizzate inviate con ogni richiesta.
  • limit.context: Token di input massimi che il modello accetta.
  • limit.output: Token massimi che il modello pu generare.

I campi limit consentono a OpenCode di capire quanto contesto ti rimane. I provider standard li estraggono automaticamente da models.dev.

Risoluzione dei problemi

Se hai problemi a configurare un provider, verifica quanto segue:

  1. Verifica la configurazione dell’autenticazione: Esegui opencode auth list per vedere se le credenziali del provider sono state aggiunte alla tua configurazione.

    Ci non si applica a provider come Amazon Bedrock, che si affidano a variabili d’ambiente per la loro autenticazione.

  2. Per i provider personalizzati, verifica la configurazione opencode e:

    • Assicurati che l’ID provider usato nel comando /connect corrisponda all’ID nella tua configurazione opencode.
    • Il pacchetto npm corretto sia usato per il provider. Ad esempio, usa @ai-sdk/cerebras per Cerebras. E per tutti gli altri provider compatibili con OpenAI, usa @ai-sdk/openai-compatible.
    • Verifica che sia usato l’endpoint API corretto nel campo options.baseURL.