Português
Documentação
Provedores

Provedores

Usando qualquer provedor de LLM no OpenCode.

O OpenCode usa o AI SDK (opens in a new tab) e o Models.dev (opens in a new tab) para suportar mais de 75 provedores de LLM e também suporta a execução de modelos locais.

Para adicionar um provedor, você precisa:

  1. Adicionar as chaves de API do provedor usando o comando /connect.
  2. Configurar o provedor na sua config do OpenCode.

Credenciais

Quando você adiciona as chaves de API de um provedor com o comando /connect, elas são armazenadas em ~/.local/share/opencode/auth.json.

Config

Você pode personalizar os provedores através da seção provider na sua config do OpenCode.

Base URL

Você pode personalizar a base URL de qualquer provedor definindo a opção baseURL. Isso é útil ao usar serviços de proxy ou endpoints personalizados.

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

OpenCode Zen

O OpenCode Zen é uma lista de modelos fornecidos pela equipe do OpenCode que foram testados e verificados para funcionar bem com o OpenCode. Saiba mais.

Dica: Se você é novo, recomendamos começar pelo OpenCode Zen.

  1. Rode o comando /connect na TUI, selecione OpenCode Zen e vá até opencode.ai/auth (opens in a new tab).

    /connect

  2. Faça login, adicione seus dados de cobrança e copie sua chave de API.

  3. Cole sua chave de API.

    ┌ API key
│
│
└ enter

  4. Rode /models na TUI para ver a lista de modelos que recomendamos.

    /models

Ele funciona como qualquer outro provedor no OpenCode e seu uso é totalmente opcional.

OpenCode Go

O OpenCode Go é um plano de assinatura de baixo custo que oferece acesso confiável a modelos populares de open coding fornecidos pela equipe do OpenCode que foram testados e verificados para funcionar bem com o OpenCode.

  1. Rode o comando /connect na TUI, selecione OpenCode Go e vá até opencode.ai/auth (opens in a new tab).

    /connect

  2. Faça login, adicione seus dados de cobrança e copie sua chave de API.

  3. Cole sua chave de API.

    ┌ API key
│
│
└ enter

  4. Rode /models na TUI para ver a lista de modelos que recomendamos.

    /models

Ele funciona como qualquer outro provedor no OpenCode e seu uso é totalmente opcional.

Diretório

Vamos analisar alguns dos provedores em detalhes. Se você quiser adicionar um provedor à lista, fique à vontade para abrir um PR.

Nota: Não vê um provedor aqui? Envie um PR.

302.AI

  1. Vá até o console da 302.AI (opens in a new tab), crie uma conta e gere uma chave de API.

  2. Rode o comando /connect e busque por 302.AI.

    /connect

  3. Insira sua chave de API da 302.AI.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo.

    /models

Amazon Bedrock

Para usar o Amazon Bedrock com o OpenCode:

  1. Vá até o Model catalog no console do Amazon Bedrock e solicite acesso aos modelos que você quer.

    Dica: Você precisa ter acesso ao modelo que quer no Amazon Bedrock.

  2. Configure a autenticação usando um dos seguintes métodos:

    Variáveis de ambiente (Início rápido)

    Defina uma destas variáveis de ambiente ao rodar o opencode:

    # Option 1: Using AWS access keys
AWS_ACCESS_KEY_ID=XXX AWS_SECRET_ACCESS_KEY=YYY opencode
 
# Option 2: Using named AWS profile
AWS_PROFILE=my-profile opencode
 
# Option 3: Using Bedrock bearer token
AWS_BEARER_TOKEN_BEDROCK=XXX opencode

    Ou adicione-as ao seu bash profile:

    ~/.bash_profile
    export AWS_PROFILE=my-dev-profile
export AWS_REGION=us-east-1

    Arquivo de configuração (Recomendado)

    Para configuração específica do projeto ou persistente, use opencode.json:

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

    Opções disponíveis:

    • region - Região da AWS (ex.: us-east-1 , eu-west-1 )

    • profile - Perfil nomeado da AWS de ~/.aws/credentials

    • endpoint - URL de endpoint personalizado para endpoints de VPC (alias para a opção genérica baseURL )

    Dica: As opções do arquivo de configuração têm precedência sobre as variáveis de ambiente.

    Avançado: Endpoints de VPC

    Se você estiver usando endpoints de VPC para o 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"
      }
    }
  }
}

    Nota: A opção endpoint é um alias para a opção genérica baseURL, usando terminologia específica da AWS. Se tanto endpoint quanto baseURL forem especificados, endpoint tem precedência.

    Métodos de autenticação

    • AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY : Crie um usuário IAM e gere chaves de acesso no AWS Console
    • AWS_PROFILE : Use perfis nomeados de ~/.aws/credentials . Primeiro configure com aws configure --profile my-profile ou aws sso login
    • AWS_BEARER_TOKEN_BEDROCK : Gere chaves de API de longo prazo no console do Amazon Bedrock
    • AWS_WEB_IDENTITY_TOKEN_FILE / AWS_ROLE_ARN : Para EKS IRSA (IAM Roles for Service Accounts) ou outros ambientes Kubernetes com federação OIDC. Essas variáveis de ambiente são injetadas automaticamente pelo Kubernetes ao usar anotações de service account.

    Precedência de autenticação

    O Amazon Bedrock usa a seguinte prioridade de autenticação:

    1. Bearer Token - variável de ambiente AWS_BEARER_TOKEN_BEDROCK ou token do comando /connect

    2. AWS Credential Chain - Perfil, chaves de acesso, credenciais compartilhadas, IAM roles, Web Identity Tokens (EKS IRSA), metadados de instância

    Nota: Quando um bearer token é definido (via /connect ou AWS_BEARER_TOKEN_BEDROCK), ele tem precedência sobre todos os métodos de credenciais da AWS, incluindo os perfis configurados.

  3. Rode o comando /models para selecionar o modelo que você quer.

    /models

Nota: Para perfis de inferência personalizados, use o nome do modelo e do provedor na chave e defina a propriedade id como o arn. Isso garante o cache correto.

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. Após se cadastrar, rode o comando /connect e selecione Anthropic.

    /connect

  2. Aqui você pode selecionar a opção Claude Pro/Max e ela abrirá seu navegador e pedirá que você se autentique.

    ┌ Select auth method
│
│ Manually enter API Key
└

  3. Agora todos os modelos da Anthropic devem estar disponíveis quando você usar o comando /models.

    /models

Existem plugins que permitem usar seus modelos Claude Pro/Max com o OpenCode. A Anthropic proíbe isso explicitamente.

Versões anteriores do OpenCode vinham com esses plugins inclusos, mas isso não acontece mais a partir da 1.3.0

Outras empresas apoiam a liberdade de escolha em ferramentas de desenvolvimento — você pode usar as seguintes assinaturas no OpenCode sem nenhuma configuração:

  • ChatGPT Plus
  • Github Copilot
  • Gitlab Duo

Atomic Chat

Você pode configurar o opencode para usar modelos locais através do Atomic Chat (opens in a new tab), um aplicativo de desktop que executa LLMs locais por trás de um servidor de API compatível com OpenAI (endpoint padrão http://127.0.0.1:1337/v1).

opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "atomic-chat": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Atomic Chat (local)",
      "options": {
        "baseURL": "http://127.0.0.1:1337/v1"
      },
      "models": {
        "<your-model-id>": {
          "name": "<your-model-name>"
        }
      }
    }
  }
}

Neste exemplo:

  • atomic-chat é o ID personalizado do provedor. Pode ser qualquer string que você quiser.
  • npm especifica o pacote a ser usado para este provedor. Aqui, @ai-sdk/openai-compatible é usado para qualquer API compatível com OpenAI.
  • name é o nome de exibição do provedor na UI.
  • options.baseURL é o endpoint do servidor local. Altere o host e a porta para corresponder à sua configuração do Atomic Chat.
  • models é um mapa de IDs de modelo para seus nomes de exibição. Cada ID precisa corresponder ao id retornado por GET /v1/models — rode curl http://127.0.0.1:1337/v1/models para listar os ids atualmente carregados no Atomic Chat.

Dica: Se as chamadas de ferramentas não estiverem funcionando bem, escolha um modelo carregado com forte suporte a chamadas de ferramentas (por exemplo, uma variante Qwen-Coder ou DeepSeek-Coder).

Azure OpenAI

Nota: Se você encontrar erros "I'm sorry, but I cannot assist with that request", tente alterar o filtro de conteúdo de DefaultV2 para Default no seu recurso do Azure.

  1. Vá até o portal do Azure (opens in a new tab) e crie um recurso Azure OpenAI. Você vai precisar de:

    • Resource name : Isso se torna parte do seu endpoint de API ( https://RESOURCE_NAME.openai.azure.com/ )
    • API key : Seja KEY 1 ou KEY 2 do seu recurso

  2. Vá até o Azure AI Foundry (opens in a new tab) e faça o deploy de um modelo.

    Nota: O nome do deployment precisa corresponder ao nome do modelo para o opencode funcionar corretamente.

  3. Rode o comando /connect e busque por Azure.

    /connect

  4. Insira sua chave de API.

    ┌ API key
│
│
└ enter

  5. Defina o nome do seu recurso como uma variável de ambiente:

    AZURE_RESOURCE_NAME=XXX opencode

    Ou adicione-o ao seu bash profile:

    ~/.bash_profile
    export AZURE_RESOURCE_NAME=XXX

  6. Rode o comando /models para selecionar o modelo que você fez deploy.

    /models

Azure Cognitive Services

  1. Vá até o portal do Azure (opens in a new tab) e crie um recurso Azure OpenAI. Você vai precisar de:

    • Resource name : Isso se torna parte do seu endpoint de API ( https://AZURE_COGNITIVE_SERVICES_RESOURCE_NAME.cognitiveservices.azure.com/ )
    • API key : Seja KEY 1 ou KEY 2 do seu recurso

  2. Vá até o Azure AI Foundry (opens in a new tab) e faça o deploy de um modelo.

    Nota: O nome do deployment precisa corresponder ao nome do modelo para o opencode funcionar corretamente.

  3. Rode o comando /connect e busque por Azure Cognitive Services.

    /connect

  4. Insira sua chave de API.

    ┌ API key
│
│
└ enter

  5. Defina o nome do seu recurso como uma variável de ambiente:

    AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode

    Ou adicione-o ao seu bash profile:

    ~/.bash_profile
    export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX

  6. Rode o comando /models para selecionar o modelo que você fez deploy.

    /models

Baseten

  1. Vá até a Baseten (opens in a new tab), crie uma conta e gere uma chave de API.

  2. Rode o comando /connect e busque por Baseten.

    /connect

  3. Insira sua chave de API da Baseten.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo.

    /models

Cerebras

  1. Vá até o console da Cerebras (opens in a new tab), crie uma conta e gere uma chave de API.

  2. Rode o comando /connect e busque por Cerebras.

    /connect

  3. Insira sua chave de API da Cerebras.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo como Qwen 3 Coder 480B.

    /models

Cloudflare AI Gateway

O Cloudflare AI Gateway permite que você acesse modelos da OpenAI, Anthropic, Workers AI e mais através de um endpoint unificado. Com o Unified Billing (opens in a new tab), você não precisa de chaves de API separadas para cada provedor.

  1. Vá até o dashboard da Cloudflare (opens in a new tab), navegue até AI > AI Gateway e crie um novo gateway. Anote seu Account ID e Gateway ID.

  2. Rode o comando /connect e busque por Cloudflare AI Gateway.

    /connect

  3. Insira seu Account ID quando solicitado.

    ┌ Enter your Cloudflare Account ID
│
│
└ enter

  4. Insira seu Gateway ID quando solicitado.

    ┌ Enter your Cloudflare AI Gateway ID
│
│
└ enter

  5. Insira seu Cloudflare API token.

    ┌ Gateway API token
│
│
└ enter

  6. Rode o comando /models para selecionar um modelo.

    /models

    Você também pode adicionar modelos através da sua config do opencode.

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

    Alternativamente, você pode definir variáveis de ambiente em vez de usar /connect.

    ~/.bash_profile
    export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
export CLOUDFLARE_GATEWAY_ID=your-gateway-id
export CLOUDFLARE_API_TOKEN=your-api-token

Cloudflare Workers AI

O Cloudflare Workers AI permite que você execute modelos de IA na rede global da Cloudflare diretamente via API REST, sem precisar de contas de provedor separadas para os modelos suportados.

  1. Vá até o dashboard da Cloudflare (opens in a new tab), navegue até Workers AI e selecione Use REST API para obter seu Account ID e criar um API token.

  2. Rode o comando /connect e busque por Cloudflare Workers AI.

    /connect

  3. Insira seu Account ID quando solicitado.

    ┌ Enter your Cloudflare Account ID
│
│
└ enter

  4. Insira sua Cloudflare API key.

    ┌ API key
│
│
└ enter

  5. Rode o comando /models para selecionar um modelo.

    /models

    Alternativamente, você pode definir variáveis de ambiente em vez de usar /connect.

    ~/.bash_profile
    export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
export CLOUDFLARE_API_KEY=your-api-token

Cortecs

  1. Vá até o console da Cortecs (opens in a new tab), crie uma conta e gere uma chave de API.

  2. Rode o comando /connect e busque por Cortecs.

    /connect

  3. Insira sua chave de API da Cortecs.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo como Kimi K2 Instruct.

    /models

DeepSeek

  1. Vá até o console da DeepSeek (opens in a new tab), crie uma conta e clique em Create new API key.

  2. Rode o comando /connect e busque por DeepSeek.

    /connect

  3. Insira sua chave de API da DeepSeek.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo da DeepSeek como DeepSeek V4 Pro.

    /models

Deep Infra

  1. Vá até o dashboard da Deep Infra (opens in a new tab), crie uma conta e gere uma chave de API.

  2. Rode o comando /connect e busque por Deep Infra.

    /connect

  3. Insira sua chave de API da Deep Infra.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo.

    /models

DigitalOcean

O Inference Engine (opens in a new tab) da DigitalOcean oferece acesso a modelos abertos como GPT-OSS, Llama, Qwen e DeepSeek, além de Inference Routers (opens in a new tab) personalizados que roteiam cada requisição para o modelo mais barato, mais rápido ou mais adequado para uma tarefa.

O OpenCode suporta dois métodos de autenticação:

  • OAuth (Recomendado) — Faça login na sua conta da DigitalOcean; o OpenCode cria automaticamente uma Model Access Key e descobre seus Models & Inference Routers disponíveis.
  • Model Access Key — Cole uma chave existente do console da DigitalOcean.

OAuth (Recomendado)

  1. Rode o comando /connect e busque por DigitalOcean.

    /connect

  2. Selecione Login with DigitalOcean.

    ┌ Select auth method
│
│ Login with DigitalOcean
│ Paste Model Access Key
└

  3. Seu navegador abre para autorizar o OpenCode. Faça login e aprove.

    Nota: O OpenCode cria uma Model Access Key chamada opencode-oauth-<timestamp> na sua conta da DigitalOcean. Você pode rotacioná-la ou revogá-la na página Model Access Keys na seção "Manage" do console da DigitalOcean, em Inference.

  4. Rode o comando /models. Seus Inference Routers aparecem no formato router: na seleção de modelos.

    /models

  5. Para captar os Inference Routers recém-criados, rode /connect novamente e selecione DigitalOcean de novo.

Usando uma Model Access Key

Se você preferir colar uma chave diretamente:

  1. Vá até a página Manage na seção Inference do console da DigitalOcean (opens in a new tab) e crie uma nova chave.

  2. Rode o comando /connect e selecione DigitalOcean, depois Paste Model Access Key.

    ┌ Enter your DigitalOcean Model Access Key
│
│
└ enter

    Nota: Os Inference Routers não são descobertos automaticamente com este método. Para exibi-los no seletor de modelos, faça login via OAuth em vez disso.

  3. Rode o comando /models para selecionar um modelo.

    /models

Variável de ambiente

Alternativamente, defina sua Model Access Key como uma variável de ambiente.

export DIGITALOCEAN_ACCESS_TOKEN=your-model-access-key

Inference Routers

Os Inference Routers permitem que você defina uma política de roteamento entre vários modelos — escolhendo o modelo mais barato, mais rápido ou mais apropriado por requisição com base na tarefa. Após o OAuth, o OpenCode exibe cada router como router:<router-name> no seletor de modelos.

Selecionar um modelo de router é uma substituição direta para qualquer outro modelo — o OpenCode encaminha sua requisição e a DigitalOcean escolhe o modelo subjacente com base na política do seu router. Saiba mais sobre os Inference Routers (opens in a new tab)

FrogBot

  1. Vá até o dashboard da FrogBot (opens in a new tab), crie uma conta e gere uma chave de API.

  2. Rode o comando /connect e busque por FrogBot.

    /connect

  3. Insira sua chave de API da FrogBot.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo.

    /models

Fireworks AI

  1. Vá até o console da Fireworks AI (opens in a new tab), crie uma conta e clique em Create API Key.

  2. Rode o comando /connect e busque por Fireworks AI.

    /connect

  3. Insira sua chave de API da Fireworks AI.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo como Kimi K2 Instruct.

    /models

GitLab Duo

Cuidado: O suporte ao GitLab Duo no OpenCode é experimental. Recursos, configuração e comportamento podem mudar em versões futuras.

O OpenCode se integra com a GitLab Duo Agent Platform (opens in a new tab), fornecendo chat agêntico com IA e capacidades nativas de chamada de ferramentas.

Nota: A GitLab Duo Agent Platform requer uma assinatura GitLab Premium ou Ultimate. Ela está disponível no GitLab.com e no GitLab Self-Managed. Consulte os pré-requisitos da GitLab Duo Agent Platform (opens in a new tab) para os requisitos completos.

  1. Rode o comando /connect e selecione GitLab.

    /connect

  2. Escolha seu método de autenticação:

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

    Usando OAuth (Recomendado)

    Selecione OAuth e seu navegador abrirá para autorização.

    Usando Personal Access Token

    1. Vá até GitLab User Settings > Access Tokens (opens in a new tab)
    2. Clique em Add new token
    3. Name: OpenCode , Scopes: api
    4. Copie o token (começa com glpat- )
    5. Insira-o no terminal

  3. Rode o comando /models para ver os modelos disponíveis.

    /models

    Três modelos baseados em Claude estão disponíveis:

    • duo-chat-haiku-4-5 (Padrão) - Respostas rápidas para tarefas rápidas
    • duo-chat-sonnet-4-5 - Desempenho equilibrado para a maioria dos fluxos de trabalho
    • duo-chat-opus-4-5 - O mais capaz para análises complexas

Nota: Você também pode especificar a variável de ambiente 'GITLAB_TOKEN' se não quiser armazenar o token no armazenamento de auth do opencode.

GitLab Auto-Hospedado

Nota: O OpenCode usa um modelo pequeno para algumas tarefas de IA, como gerar o título da sessão. Por padrão, ele é configurado para usar gpt-5-nano, hospedado pelo Zen. Para bloquear o OpenCode a usar apenas a sua própria instância hospedada no GitLab, adicione o seguinte ao seu arquivo opencode.json. Também é recomendado desativar o compartilhamento de sessão.

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

Para instâncias GitLab auto-hospedadas:

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

Se sua instância executa um AI Gateway personalizado:

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

Ou adicione ao seu bash profile:

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

Nota: Seu administrador do GitLab precisa:

  1. Ativar o GitLab Duo (opens in a new tab) para o usuário, grupo ou instância
  2. Ativar a Agent Platform (opens in a new tab) (GitLab 18.8+) ou ativar os recursos beta e experimentais (opens in a new tab) (GitLab 18.7 e anteriores)
  3. Para Self-Managed, configurar sua instância (opens in a new tab)
OAuth para instâncias Auto-Hospedadas

Para fazer o OAuth funcionar na sua instância auto-hospedada, você precisa criar um novo aplicativo (Settings → Applications) com a callback URL http://127.0.0.1:8080/callback e os seguintes scopes:

  • api (Access the API on your behalf)
  • read_user (Read your personal information)
  • read_repository (Allows read-only access to the repository)

Em seguida, exponha o ID do aplicativo como variável de ambiente:

export GITLAB_OAUTH_CLIENT_ID=your_application_id_here

Mais documentação na página inicial do opencode-gitlab-auth (opens in a new tab).

Configuração

Personalize através do opencode.json:

opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "gitlab": {
      "options": {
        "instanceUrl": "https://gitlab.com"
      }
    }
  }
}
Modelos de Workflow da GitLab Duo Agent Platform (DAP)

Os modelos de workflow do DAP fornecem um caminho de execução alternativo que roteia chamadas de ferramentas através do Duo Workflow Service (DWS) do GitLab em vez do chat agêntico padrão. Quando um modelo duo-workflow-* é selecionado, o OpenCode irá:

  1. Descobrir os modelos disponíveis no seu namespace do GitLab
  2. Apresentar um seletor de escolha se vários modelos estiverem disponíveis
  3. Fazer cache do modelo selecionado no disco para inicializações subsequentes rápidas
  4. Rotear as requisições de execução de ferramentas pelo sistema de ferramentas com permissões controladas do OpenCode

Os modelos de workflow do DAP disponíveis seguem a convenção de nomenclatura duo-workflow-* e são descobertos dinamicamente da sua instância do GitLab.

Ferramentas de API do GitLab (Opcional, mas altamente recomendado)

Para acessar as ferramentas do GitLab (merge requests, issues, pipelines, CI/CD, etc.):

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

Este plugin fornece capacidades abrangentes de gerenciamento de repositórios GitLab, incluindo revisões de MR, rastreamento de issues, monitoramento de pipelines e mais.

GitHub Copilot

Para usar sua assinatura do GitHub Copilot com o opencode:

Nota: Alguns modelos podem exigir uma assinatura Pro+ (opens in a new tab) para serem usados.

  1. Rode o comando /connect e busque por GitHub Copilot.

    /connect

  2. Navegue até github.com/login/device (opens in a new tab) e insira o código.

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

  3. Agora rode o comando /models para selecionar o modelo que você quer.

    /models

Google Vertex AI

Para usar o Google Vertex AI com o OpenCode:

  1. Vá até o Model Garden no Google Cloud Console e verifique os modelos disponíveis na sua região.

    Nota: Você precisa ter um projeto do Google Cloud com a Vertex AI API habilitada.

  2. Defina as variáveis de ambiente necessárias:

    • GOOGLE_CLOUD_PROJECT : O ID do seu projeto do Google Cloud

    • VERTEX_LOCATION (opcional): A região para o Vertex AI (padrão global )

    • Autenticação (escolha uma):

      • GOOGLE_APPLICATION_CREDENTIALS : Caminho para o arquivo de chave JSON da sua service account
      • Autentique usando a gcloud CLI: gcloud auth application-default login

    Defina-as ao rodar o opencode.

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

    Ou adicione-as ao seu bash profile.

    ~/.bash_profile
    export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
export GOOGLE_CLOUD_PROJECT=your-project-id
export VERTEX_LOCATION=global

Dica: A região global melhora a disponibilidade e reduz erros sem custo extra. Use endpoints regionais (ex.: us-central1) para requisitos de residência de dados. Saiba mais (opens in a new tab)

  1. Rode o comando /models para selecionar o modelo que você quer.

    /models

Groq

  1. Vá até o console da Groq (opens in a new tab), clique em Create API Key e copie a chave.

  2. Rode o comando /connect e busque por Groq.

    /connect

  3. Insira a chave de API do provedor.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar o que você quer.

    /models

Hugging Face

Os Hugging Face Inference Providers (opens in a new tab) oferecem acesso a modelos abertos suportados por mais de 17 provedores.

  1. Vá até as configurações do Hugging Face (opens in a new tab) para criar um token com permissão para fazer chamadas aos Inference Providers.

  2. Rode o comando /connect e busque por Hugging Face.

    /connect

  3. Insira seu token do Hugging Face.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo como Kimi-K2-Instruct ou GLM-4.6.

    /models

Helicone

O Helicone (opens in a new tab) é uma plataforma de observabilidade de LLM que fornece logging, monitoramento e analytics para suas aplicações de IA. O Helicone AI Gateway roteia suas requisições para o provedor apropriado automaticamente com base no modelo.

  1. Vá até o Helicone (opens in a new tab), crie uma conta e gere uma chave de API no seu dashboard.

  2. Rode o comando /connect e busque por Helicone.

    /connect

  3. Insira sua chave de API do Helicone.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo.

    /models

Para mais provedores e recursos avançados como caching e rate limiting, confira a documentação do Helicone (opens in a new tab).

Configs opcionais

Caso você veja um recurso ou modelo do Helicone que não é configurado automaticamente pelo opencode, você sempre pode configurá-lo você mesmo.

Aqui está o Diretório de Modelos do Helicone (opens in a new tab), você vai precisar dele para pegar os IDs dos modelos que quer adicionar.

~/.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",
        },
      },
    },
  },
}

Headers personalizados

O Helicone suporta headers personalizados para recursos como caching, rastreamento de usuário e gerenciamento de sessão. Adicione-os à config do seu provedor 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",
        },
      },
    },
  },
}
Rastreamento de sessão

O recurso Sessions (opens in a new tab) do Helicone permite que você agrupe requisições de LLM relacionadas. Use o plugin opencode-helicone-session (opens in a new tab) para registrar automaticamente cada conversa do OpenCode como uma sessão no Helicone.

npm install -g opencode-helicone-session

Adicione-o à sua config.

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

O plugin injeta os headers Helicone-Session-Id e Helicone-Session-Name nas suas requisições. Na página Sessions do Helicone, você verá cada conversa do OpenCode listada como uma sessão separada.

Headers comuns do Helicone
HeaderDescrição
Helicone-Cache-EnabledHabilita o cache de respostas (true/false)
Helicone-User-IdRastreia métricas por usuário
Helicone-Property-[Name]Adiciona propriedades personalizadas (ex.: Helicone-Property-Environment)
Helicone-Prompt-IdAssocia requisições a versões de prompt

Consulte o Diretório de Headers do Helicone (opens in a new tab) para todos os headers disponíveis.

llama.cpp

Você pode configurar o opencode para usar modelos locais através do utilitário llama-server do llama.cpp (opens in a new tab)

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

Neste exemplo:

  • llama.cpp é o ID personalizado do provedor. Pode ser qualquer string que você quiser.
  • npm especifica o pacote a ser usado para este provedor. Aqui, @ai-sdk/openai-compatible é usado para qualquer API compatível com OpenAI.
  • name é o nome de exibição do provedor na UI.
  • options.baseURL é o endpoint do servidor local.
  • models é um mapa de IDs de modelo para suas configurações. O nome do modelo será exibido na lista de seleção de modelos.

IO.NET

A IO.NET oferece 17 modelos otimizados para vários casos de uso:

  1. Vá até o console da IO.NET (opens in a new tab), crie uma conta e gere uma chave de API.

  2. Rode o comando /connect e busque por IO.NET.

    /connect

  3. Insira sua chave de API da IO.NET.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo.

    /models

LM Studio

Você pode configurar o opencode para usar modelos locais através do 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)"
        }
      }
    }
  }
}

Neste exemplo:

  • lmstudio é o ID personalizado do provedor. Pode ser qualquer string que você quiser.
  • npm especifica o pacote a ser usado para este provedor. Aqui, @ai-sdk/openai-compatible é usado para qualquer API compatível com OpenAI.
  • name é o nome de exibição do provedor na UI.
  • options.baseURL é o endpoint do servidor local.
  • models é um mapa de IDs de modelo para suas configurações. O nome do modelo será exibido na lista de seleção de modelos.

Moonshot AI

Para usar o Kimi K2 da Moonshot AI:

  1. Vá até o console da Moonshot AI (opens in a new tab), crie uma conta e clique em Create API key.

  2. Rode o comando /connect e busque por Moonshot AI.

    /connect

  3. Insira sua chave de API da Moonshot.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar Kimi K2.

    /models

MiniMax

  1. Vá até o console de API da MiniMax (opens in a new tab), crie uma conta e gere uma chave de API.

  2. Rode o comando /connect e busque por MiniMax.

    /connect

  3. Insira sua chave de API da MiniMax.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo como M2.1.

    /models

NVIDIA

A NVIDIA oferece acesso aos modelos Nemotron e a muitos outros modelos abertos através do build.nvidia.com (opens in a new tab) gratuitamente.

  1. Vá até build.nvidia.com (opens in a new tab), crie uma conta e gere uma chave de API.

  2. Rode o comando /connect e busque por NVIDIA.

    /connect

  3. Insira sua chave de API da NVIDIA.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo como nemotron-3-super-120b-a12b.

    /models

On-Prem / NIM

Você também pode usar modelos da NVIDIA localmente via NVIDIA NIM (opens in a new tab) definindo uma base URL personalizada.

opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "nvidia": {
      "options": {
        "baseURL": "http://localhost:8000/v1"
      }
    }
  }
}

Variável de ambiente

Alternativamente, defina sua chave de API como uma variável de ambiente.

export NVIDIA_API_KEY=nvapi-your-key-here

Nebius Token Factory

  1. Vá até o console da Nebius Token Factory (opens in a new tab), crie uma conta e clique em Add Key.

  2. Rode o comando /connect e busque por Nebius Token Factory.

    /connect

  3. Insira sua chave de API da Nebius Token Factory.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo como Kimi K2 Instruct.

    /models

Ollama

Você pode configurar o opencode para usar modelos locais através do Ollama.

Dica: O Ollama pode se configurar automaticamente para o OpenCode. Veja a documentação de integração do Ollama (opens in a new tab) para detalhes.

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

Neste exemplo:

  • ollama é o ID personalizado do provedor. Pode ser qualquer string que você quiser.
  • npm especifica o pacote a ser usado para este provedor. Aqui, @ai-sdk/openai-compatible é usado para qualquer API compatível com OpenAI.
  • name é o nome de exibição do provedor na UI.
  • options.baseURL é o endpoint do servidor local.
  • models é um mapa de IDs de modelo para suas configurações. O nome do modelo será exibido na lista de seleção de modelos.

Dica: Se as chamadas de ferramentas não estiverem funcionando, tente aumentar o num_ctx no Ollama. Comece em torno de 16k - 32k.

Ollama Cloud

Para usar o Ollama Cloud com o OpenCode:

  1. Vá até https://ollama.com/ (opens in a new tab) e faça login ou crie uma conta.

  2. Navegue até Settings > Keys e clique em Add API Key para gerar uma nova chave de API.

  3. Copie a chave de API para usar no OpenCode.

  4. Rode o comando /connect e busque por Ollama Cloud.

    /connect

  5. Insira sua chave de API do Ollama Cloud.

    ┌ API key
│
│
└ enter

  6. Importante: Antes de usar modelos na nuvem no OpenCode, você precisa baixar as informações do modelo localmente:

    ollama pull gpt-oss:20b-cloud

  7. Rode o comando /models para selecionar seu modelo do Ollama Cloud.

    /models

OpenAI

Recomendamos se cadastrar no ChatGPT Plus ou Pro (opens in a new tab).

  1. Após se cadastrar, rode o comando /connect e selecione OpenAI.

    /connect

  2. Aqui você pode selecionar a opção ChatGPT Plus/Pro e ela abrirá seu navegador e pedirá que você se autentique.

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

  3. Agora todos os modelos da OpenAI devem estar disponíveis quando você usar o comando /models.

    /models
Usando chaves de API

Se você já tem uma chave de API, pode selecionar Manually enter API Key e colá-la no seu terminal.

OpenCode Zen

O OpenCode Zen é uma lista de modelos testados e verificados fornecidos pela equipe do OpenCode. Saiba mais.

  1. Faça login no OpenCode Zen (opens in a new tab) e clique em Create API Key.

  2. Rode o comando /connect e busque por OpenCode Zen.

    /connect

  3. Insira sua chave de API do OpenCode.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo como Qwen 3 Coder 480B.

    /models

OpenRouter

  1. Vá até o dashboard da OpenRouter (opens in a new tab), clique em Create API Key e copie a chave.

  2. Rode o comando /connect e busque por OpenRouter.

    /connect

  3. Insira a chave de API do provedor.

    ┌ API key
│
│
└ enter

  4. Muitos modelos da OpenRouter vêm pré-carregados por padrão, rode o comando /models para selecionar o que você quer.

    /models

    Você também pode adicionar modelos extras através da sua config do opencode.

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

  5. Você também pode personalizá-los através da sua config do opencode. Aqui está um exemplo especificando um provedor

    opencode.json
    {
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openrouter": {
      "models": {
        "moonshotai/kimi-k2": {
          "options": {
            "provider": {
              "order": ["baseten"],
              "allow_fallbacks": false
            }
          }
        }
      }
    }
  }
}

LLM Gateway

  1. Vá até o dashboard da LLM Gateway (opens in a new tab), clique em Create API Key e copie a chave.

  2. Rode o comando /connect e busque por LLM Gateway.

    /connect

  3. Insira a chave de API do provedor.

    ┌ API key
│
│
└ enter

  4. Muitos modelos da LLM Gateway vêm pré-carregados por padrão, rode o comando /models para selecionar o que você quer.

    /models

    Você também pode adicionar modelos extras através da sua config do opencode.

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

  5. Você também pode personalizá-los através da sua config do opencode. Aqui está um exemplo especificando um provedor

    opencode.json
    {
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llmgateway": {
      "models": {
        "glm-4.7": {
          "name": "GLM 4.7"
        },
        "gpt-5.2": {
          "name": "GPT-5.2"
        },
        "gemini-2.5-pro": {
          "name": "Gemini 2.5 Pro"
        },
        "claude-3-5-sonnet-20241022": {
          "name": "Claude 3.5 Sonnet"
        }
      }
    }
  }
}

SAP AI Core

O SAP AI Core oferece acesso a mais de 40 modelos da OpenAI, Anthropic, Google, Amazon, Meta, Mistral e AI21 através de uma plataforma unificada.

  1. Vá até o seu SAP BTP Cockpit (opens in a new tab), navegue até a instância de serviço do seu SAP AI Core e crie uma service key.

    Dica: A service key é um objeto JSON contendo clientid, clientsecret, url e serviceurls.AI_API_URL. Você pode encontrar sua instância do AI Core em Services > Instances and Subscriptions no BTP Cockpit.

  2. Rode o comando /connect e busque por SAP AI Core.

    /connect

  3. Insira o JSON da sua service key.

    ┌ Service key
│
│
└ enter

    Ou defina a variável de ambiente AICORE_SERVICE_KEY:

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

    Ou adicione-a ao seu bash profile:

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

  4. Opcionalmente, defina o deployment ID e o resource group:

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

    Nota: Essas configurações são opcionais e devem ser configuradas de acordo com a sua instalação do SAP AI Core.

  5. Rode o comando /models para selecionar entre mais de 40 modelos disponíveis.

    /models

STACKIT

O STACKIT AI Model Serving oferece um ambiente de hospedagem soberano totalmente gerenciado para modelos de IA, com foco em LLMs como Llama, Mistral e Qwen, com máxima soberania de dados em infraestrutura europeia.

  1. Vá até o Portal STACKIT (opens in a new tab), navegue até AI Model Serving e crie um auth token para o seu projeto.

    Dica: Você precisa de uma conta de cliente STACKIT, uma conta de usuário e um projeto antes de criar auth tokens.

  2. Rode o comando /connect e busque por STACKIT.

    /connect

  3. Insira seu auth token do STACKIT AI Model Serving.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar entre modelos disponíveis como Qwen3-VL 235B ou Llama 3.3 70B.

    /models

OVHcloud AI Endpoints

  1. Vá até o painel da OVHcloud (opens in a new tab). Navegue até a seção Public Cloud, AI & Machine Learning > AI Endpoints e, na aba API Keys, clique em Create a new API key.

  2. Rode o comando /connect e busque por OVHcloud AI Endpoints.

    /connect

  3. Insira sua chave de API do OVHcloud AI Endpoints.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo como gpt-oss-120b.

    /models

Scaleway

Para usar as Scaleway Generative APIs (opens in a new tab) com o Opencode:

  1. Vá até as configurações de IAM do Console Scaleway (opens in a new tab) para gerar uma nova chave de API.

  2. Rode o comando /connect e busque por Scaleway.

    /connect

  3. Insira sua chave de API da Scaleway.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo como devstral-2-123b-instruct-2512 ou gpt-oss-120b.

    /models

Together AI

  1. Vá até o console da Together AI (opens in a new tab), crie uma conta e clique em Add Key.

  2. Rode o comando /connect e busque por Together AI.

    /connect

  3. Insira sua chave de API da Together AI.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo como Kimi K2 Instruct.

    /models

Venice AI

  1. Vá até o console da Venice AI (opens in a new tab), crie uma conta e gere uma chave de API.

  2. Rode o comando /connect e busque por Venice AI.

    /connect

  3. Insira sua chave de API da Venice AI.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo como Llama 3.3 70B.

    /models

Vercel AI Gateway

O Vercel AI Gateway permite que você acesse modelos da OpenAI, Anthropic, Google, xAI e mais através de um endpoint unificado. Os modelos são oferecidos pelo preço de lista, sem markup.

  1. Vá até o dashboard da Vercel (opens in a new tab), navegue até a aba AI Gateway e clique em API keys para criar uma nova chave de API.

  2. Rode o comando /connect e busque por Vercel AI Gateway.

    /connect

  3. Insira sua chave de API do Vercel AI Gateway.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo.

    /models

Você também pode personalizar os modelos através da sua config do opencode. Aqui está um exemplo especificando a ordem de roteamento de provedores.

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

Algumas opções úteis de roteamento:

OpçãoDescrição
orderSequência de provedores a tentar
onlyRestringe a provedores específicos
zeroDataRetentionUsa apenas provedores com políticas de zero retenção de dados

xAI

Três formas de autenticar: uma assinatura SuperGrok via OAuth no navegador, a mesma assinatura SuperGrok via um fluxo de device-code headless (para VPS / SSH / Docker), ou uma chave de API pré-paga do console da xAI.

Opção A — SuperGrok OAuth (login no navegador)

  1. Rode o comando /connect e busque por xAI.

    /connect

  2. Selecione xAI Grok OAuth (SuperGrok Subscription). O OpenCode abre a tela de consentimento da xAI no seu navegador e aguarda o callback em http://127.0.0.1:56121/callback.

  3. Rode o comando /models para selecionar um modelo Grok.

    /models

O OpenCode atualiza o token de acesso OAuth automaticamente. Qualquer plano Grok ou X Premium que inclua acesso à Grok API funciona; você não precisa de uma XAI_API_KEY separada.

Opção B — SuperGrok device-code (headless / servidor remoto / VPS)

Use isto quando o OpenCode estiver rodando em algum lugar onde um navegador não consiga alcançar o redirecionamento de loopback: uma VPS, uma máquina de desenvolvimento remota via SSH, dentro do Docker, em CI, etc. Nenhuma porta de callback é aberta no host que roda o OpenCode — em vez disso, a xAI entrega à CLI um código curto que você digita em um navegador em qualquer outro dispositivo (laptop, celular, ...).

  1. Rode o comando /connect no host remoto e busque por xAI.

    /connect

  2. Selecione xAI Grok OAuth (Headless / Remote / VPS). O OpenCode imprime uma URL de verificação e um código de usuário curto.

    Open https://x.ai/device on any device and enter code: ABCD-1234

  3. Abra a URL em um dispositivo que tenha um navegador (seu laptop ou celular), insira o código e aprove a tela de consentimento. O OpenCode faz polling no endpoint de token da xAI e armazena os tokens OAuth resultantes assim que você aprovar. A atualização do token funciona da mesma forma que na Opção A.

Opção C — chave de API

  1. Vá até o console da xAI (opens in a new tab), crie uma conta e gere uma chave de API.

  2. Rode o comando /connect e busque por xAI.

    /connect

  3. Selecione Manually enter API Key e cole sua chave de API da xAI.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo como Grok Beta.

    /models

Z.AI

  1. Vá até o console de API da Z.AI (opens in a new tab), crie uma conta e clique em Create a new API key.

  2. Rode o comando /connect e busque por Z.AI.

    /connect

    Se você for assinante do GLM Coding Plan, selecione Z.AI Coding Plan.

  3. Insira sua chave de API da Z.AI.

    ┌ API key
│
│
└ enter

  4. Rode o comando /models para selecionar um modelo como GLM-4.7.

    /models

ZenMux

  1. Vá até o dashboard da ZenMux (opens in a new tab), clique em Create API Key e copie a chave.

  2. Rode o comando /connect e busque por ZenMux.

    /connect

  3. Insira a chave de API do provedor.

    ┌ API key
│
│
└ enter

  4. Muitos modelos da ZenMux vêm pré-carregados por padrão, rode o comando /models para selecionar o que você quer.

    /models

    Você também pode adicionar modelos extras através da sua config do opencode.

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

Provedor personalizado

Para adicionar qualquer provedor compatível com OpenAI que não esteja listado no comando /connect:

Dica: Você pode usar qualquer provedor compatível com OpenAI no opencode. A maioria dos provedores de IA modernos oferece APIs compatíveis com OpenAI.

  1. Rode o comando /connect e role para baixo até Other.

    $ /connect
 
┌  Add credential
│
◆  Select provider
│  ...
│  ● Other
└

  2. Insira um ID único para o provedor.

    $ /connect
 
┌  Add credential
│
◇  Enter provider id
│  myprovider
└

    Nota: Escolha um ID fácil de lembrar, você vai usá-lo no seu arquivo de configuração.

  3. Insira sua chave de API para o provedor.

    $ /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. Crie ou atualize seu arquivo opencode.json no diretório do seu projeto:

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

    Aqui estão as opções de configuração:

    • npm : Pacote do AI SDK a ser usado, @ai-sdk/openai-compatible para provedores compatíveis com OpenAI (para /v1/chat/completions ). Se o seu provedor/modelo usa /v1/responses , use @ai-sdk/openai .
    • name : Nome de exibição na UI.
    • models : Modelos disponíveis.
    • options.baseURL : URL do endpoint da API.
    • options.apiKey : Opcionalmente, defina a chave de API, se não estiver usando auth.
    • options.headers : Opcionalmente, defina headers personalizados.

    Mais sobre as opções avançadas no exemplo abaixo.

  5. Rode o comando /models e seu provedor e modelos personalizados aparecerão na lista de seleção.

Exemplo

Aqui está um exemplo definindo as opções apiKey, headers e limit do modelo.

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

Detalhes da configuração:

  • apiKey : Definido usando a sintaxe de variável env, saiba mais .
  • headers : Headers personalizados enviados com cada requisição.
  • limit.context : Máximo de tokens de entrada que o modelo aceita.
  • limit.output : Máximo de tokens que o modelo pode gerar.

Os campos limit permitem que o OpenCode entenda quanto contexto você ainda tem. Provedores padrão puxam esses valores do models.dev automaticamente.

Solução de problemas

Se você estiver com dificuldades para configurar um provedor, verifique o seguinte:

  1. Verifique a configuração de auth: Rode opencode auth list para ver se as credenciais do provedor foram adicionadas à sua config. Isso não se aplica a provedores como o Amazon Bedrock, que dependem de variáveis de ambiente para sua auth.

  2. Para provedores personalizados, verifique a config do opencode e:

    • Certifique-se de que o ID do provedor usado no comando /connect corresponde ao ID na sua config do opencode.
    • Que o pacote npm correto é usado para o provedor. Por exemplo, use @ai-sdk/cerebras para a Cerebras. E para todos os outros provedores compatíveis com OpenAI, use @ai-sdk/openai-compatible (para /v1/chat/completions ); se um modelo usa /v1/responses , use @ai-sdk/openai . Para configurações mistas sob um provedor, você pode sobrescrever por modelo via provider.npm .
    • Verifique se o endpoint de API correto é usado no campo options.baseURL .
ConfiguraçãoRede