Español
Documentación
Proveedores

Proveedores

Usar cualquier proveedor de LLM en OpenCode.

OpenCode usa el AI SDK (opens in a new tab) y Models.dev (opens in a new tab) para admitir más de 75 proveedores de LLM y permite ejecutar modelos locales.

Para agregar un proveedor necesitas:

  1. Agregar las claves de API del proveedor usando el comando /connect.
  2. Configurar el proveedor en tu configuración de OpenCode.

Credenciales

Cuando agregas las claves de API de un proveedor con el comando /connect, se almacenan en ~/.local/share/opencode/auth.json.

Config

Puedes personalizar los proveedores a través de la sección provider en tu configuración de OpenCode.

Base URL

Puedes personalizar la URL base de cualquier proveedor estableciendo la opción baseURL. Esto es útil cuando usas servicios de proxy o endpoints personalizados.

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

OpenCode Zen

OpenCode Zen es una lista de modelos proporcionados por el equipo de OpenCode que han sido probados y verificados para funcionar bien con OpenCode. Más información.

Consejo: Si eres nuevo, recomendamos empezar con OpenCode Zen.

  1. Ejecuta el comando /connect en la TUI, selecciona OpenCode Zen y dirígete a opencode.ai/auth (opens in a new tab).

    /connect

  2. Inicia sesión, agrega tus datos de facturación y copia tu clave de API.

  3. Pega tu clave de API.

    ┌ API key
│
│
└ enter

  4. Ejecuta /models en la TUI para ver la lista de modelos que recomendamos.

    /models

Funciona como cualquier otro proveedor en OpenCode y su uso es completamente opcional.

OpenCode Go

OpenCode Go es un plan de suscripción de bajo costo que proporciona acceso fiable a modelos de programación abiertos populares proporcionados por el equipo de OpenCode que han sido probados y verificados para funcionar bien con OpenCode.

  1. Ejecuta el comando /connect en la TUI, selecciona OpenCode Go y dirígete a opencode.ai/auth (opens in a new tab).

    /connect

  2. Inicia sesión, agrega tus datos de facturación y copia tu clave de API.

  3. Pega tu clave de API.

    ┌ API key
│
│
└ enter

  4. Ejecuta /models en la TUI para ver la lista de modelos que recomendamos.

    /models

Funciona como cualquier otro proveedor en OpenCode y su uso es completamente opcional.

Directorio

Veamos algunos de los proveedores en detalle. Si quieres agregar un proveedor a la lista, no dudes en abrir un PR.

Nota: ¿No ves un proveedor aquí? Envía un PR.

302.AI

  1. Dirígete a la consola de 302.AI (opens in a new tab), crea una cuenta y genera una clave de API.

  2. Ejecuta el comando /connect y busca 302.AI.

    /connect

  3. Ingresa tu clave de API de 302.AI.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo.

    /models

Amazon Bedrock

Para usar Amazon Bedrock con OpenCode:

  1. Dirígete al Model catalog en la consola de Amazon Bedrock y solicita acceso a los modelos que quieras.

    Consejo: Necesitas tener acceso al modelo que quieres en Amazon Bedrock.

  2. Configura la autenticación usando uno de los siguientes métodos:

    Variables de entorno (Inicio rápido)

    Establece una de estas variables de entorno mientras ejecutas 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

    O agrégalas a tu perfil de bash:

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

    Archivo de configuración (Recomendado)

    Para una configuración específica del proyecto 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"
      }
    }
  }
}

    Opciones disponibles:

    • region - Región de AWS (por ejemplo, us-east-1 , eu-west-1 )

    • profile - Perfil con nombre de AWS de ~/.aws/credentials

    • endpoint - URL de endpoint personalizada para endpoints de VPC (alias de la opción genérica baseURL )

    Consejo: Las opciones del archivo de configuración tienen prioridad sobre las variables de entorno.

    Avanzado: Endpoints de VPC

    Si usas endpoints de VPC para 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: La opción endpoint es un alias de la opción genérica baseURL, usando terminología específica de AWS. Si se especifican tanto endpoint como baseURL, endpoint tiene prioridad.

    Métodos de autenticación

    • AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY : Crea un usuario de IAM y genera claves de acceso en la consola de AWS
    • AWS_PROFILE : Usa perfiles con nombre de ~/.aws/credentials . Primero configura con aws configure --profile my-profile o aws sso login
    • AWS_BEARER_TOKEN_BEDROCK : Genera claves de API de largo plazo desde la consola de Amazon Bedrock
    • AWS_WEB_IDENTITY_TOKEN_FILE / AWS_ROLE_ARN : Para EKS IRSA (IAM Roles for Service Accounts) u otros entornos de Kubernetes con federación OIDC. Estas variables de entorno son inyectadas automáticamente por Kubernetes al usar anotaciones de cuentas de servicio.

    Prioridad de autenticación

    Amazon Bedrock usa la siguiente prioridad de autenticación:

    1. Bearer Token - Variable de entorno AWS_BEARER_TOKEN_BEDROCK o token del comando /connect

    2. AWS Credential Chain - Perfil, claves de acceso, credenciales compartidas, roles de IAM, Web Identity Tokens (EKS IRSA), metadatos de instancia

    Nota: Cuando se establece un bearer token (mediante /connect o AWS_BEARER_TOKEN_BEDROCK), tiene prioridad sobre todos los métodos de credenciales de AWS, incluidos los perfiles configurados.

  3. Ejecuta el comando /models para seleccionar el modelo que quieras.

    /models

Nota: Para perfiles de inferencia personalizados, usa el nombre del modelo y del proveedor en la clave y establece la propiedad id en el arn. Esto garantiza un almacenamiento en caché correcto.

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 vez que te hayas registrado, ejecuta el comando /connect y selecciona Anthropic.

    /connect

  2. Aquí puedes seleccionar la opción Claude Pro/Max y abrirá tu navegador y te pedirá que te autentiques.

    ┌ Select auth method
│
│ Manually enter API Key
└

  3. Ahora todos los modelos de Anthropic deberían estar disponibles cuando uses el comando /models.

    /models

Hay plugins que te permiten usar tus modelos de Claude Pro/Max con OpenCode. Anthropic prohíbe esto explícitamente.

Las versiones anteriores de OpenCode venían con estos plugins incluidos, pero ya no es el caso a partir de la 1.3.0

Otras empresas apoyan la libertad de elección con las herramientas para desarrolladores: puedes usar las siguientes suscripciones en OpenCode sin ninguna configuración:

  • ChatGPT Plus
  • Github Copilot
  • Gitlab Duo

Atomic Chat

Puedes configurar opencode para usar modelos locales a través de Atomic Chat (opens in a new tab), una aplicación de escritorio que ejecuta LLM locales detrás de un servidor de API compatible con OpenAI (endpoint por defecto 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>"
        }
      }
    }
  }
}

En este ejemplo:

  • atomic-chat es el ID de proveedor personalizado. Puede ser cualquier cadena que quieras.
  • npm especifica el paquete que se usará para este proveedor. Aquí, @ai-sdk/openai-compatible se usa para cualquier API compatible con OpenAI.
  • name es el nombre de visualización del proveedor en la UI.
  • options.baseURL es el endpoint del servidor local. Cambia el host y el puerto para que coincidan con tu configuración de Atomic Chat.
  • models es un mapa de IDs de modelo a sus nombres de visualización. Cada ID debe coincidir con el id devuelto por GET /v1/models — ejecuta curl http://127.0.0.1:1337/v1/models para listar los ids cargados actualmente en Atomic Chat.

Consejo: Si las llamadas a herramientas no funcionan bien, elige un modelo cargado con buen soporte de llamadas a herramientas (por ejemplo, una variante de Qwen-Coder o DeepSeek-Coder).

Azure OpenAI

Nota: Si encuentras errores del tipo "I'm sorry, but I cannot assist with that request", prueba a cambiar el filtro de contenido de DefaultV2 a Default en tu recurso de Azure.

  1. Dirígete al portal de Azure (opens in a new tab) y crea un recurso Azure OpenAI. Necesitarás:

    • Resource name : Esto se convierte en parte de tu endpoint de API ( https://RESOURCE_NAME.openai.azure.com/ )
    • API key : Ya sea KEY 1 o KEY 2 de tu recurso

  2. Ve a Azure AI Foundry (opens in a new tab) y despliega un modelo.

    Nota: El nombre del despliegue debe coincidir con el nombre del modelo para que opencode funcione correctamente.

  3. Ejecuta el comando /connect y busca Azure.

    /connect

  4. Ingresa tu clave de API.

    ┌ API key
│
│
└ enter

  5. Establece el nombre de tu recurso como una variable de entorno:

    AZURE_RESOURCE_NAME=XXX opencode

    O agrégala a tu perfil de bash:

    ~/.bash_profile
    export AZURE_RESOURCE_NAME=XXX

  6. Ejecuta el comando /models para seleccionar tu modelo desplegado.

    /models

Azure Cognitive Services

  1. Dirígete al portal de Azure (opens in a new tab) y crea un recurso Azure OpenAI. Necesitarás:

    • Resource name : Esto se convierte en parte de tu endpoint de API ( https://AZURE_COGNITIVE_SERVICES_RESOURCE_NAME.cognitiveservices.azure.com/ )
    • API key : Ya sea KEY 1 o KEY 2 de tu recurso

  2. Ve a Azure AI Foundry (opens in a new tab) y despliega un modelo.

    Nota: El nombre del despliegue debe coincidir con el nombre del modelo para que opencode funcione correctamente.

  3. Ejecuta el comando /connect y busca Azure Cognitive Services.

    /connect

  4. Ingresa tu clave de API.

    ┌ API key
│
│
└ enter

  5. Establece el nombre de tu recurso como una variable de entorno:

    AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode

    O agrégala a tu perfil de bash:

    ~/.bash_profile
    export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX

  6. Ejecuta el comando /models para seleccionar tu modelo desplegado.

    /models

Baseten

  1. Dirígete a Baseten (opens in a new tab), crea una cuenta y genera una clave de API.

  2. Ejecuta el comando /connect y busca Baseten.

    /connect

  3. Ingresa tu clave de API de Baseten.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo.

    /models

Cerebras

  1. Dirígete a la consola de Cerebras (opens in a new tab), crea una cuenta y genera una clave de API.

  2. Ejecuta el comando /connect y busca Cerebras.

    /connect

  3. Ingresa tu clave de API de Cerebras.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo como Qwen 3 Coder 480B.

    /models

Cloudflare AI Gateway

Cloudflare AI Gateway te permite acceder a modelos de OpenAI, Anthropic, Workers AI y más a través de un endpoint unificado. Con la facturación unificada (opens in a new tab) no necesitas claves de API separadas para cada proveedor.

  1. Dirígete al panel de Cloudflare (opens in a new tab), navega a AI > AI Gateway y crea un nuevo gateway. Anota tu Account ID y Gateway ID.

  2. Ejecuta el comando /connect y busca Cloudflare AI Gateway.

    /connect

  3. Ingresa tu Account ID cuando se te solicite.

    ┌ Enter your Cloudflare Account ID
│
│
└ enter

  4. Ingresa tu Gateway ID cuando se te solicite.

    ┌ Enter your Cloudflare AI Gateway ID
│
│
└ enter

  5. Ingresa tu token de API de Cloudflare.

    ┌ Gateway API token
│
│
└ enter

  6. Ejecuta el comando /models para seleccionar un modelo.

    /models

    También puedes agregar modelos a través de tu configuración de opencode.

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

    Alternativamente, puedes establecer variables de entorno en lugar 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

Cloudflare Workers AI te permite ejecutar modelos de IA en la red global de Cloudflare directamente vía REST API, sin necesidad de cuentas de proveedor separadas para los modelos compatibles.

  1. Dirígete al panel de Cloudflare (opens in a new tab), navega a Workers AI y selecciona Use REST API para obtener tu Account ID y crear un token de API.

  2. Ejecuta el comando /connect y busca Cloudflare Workers AI.

    /connect

  3. Ingresa tu Account ID cuando se te solicite.

    ┌ Enter your Cloudflare Account ID
│
│
└ enter

  4. Ingresa tu clave de API de Cloudflare.

    ┌ API key
│
│
└ enter

  5. Ejecuta el comando /models para seleccionar un modelo.

    /models

    Alternativamente, puedes establecer variables de entorno en lugar de usar /connect.

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

Cortecs

  1. Dirígete a la consola de Cortecs (opens in a new tab), crea una cuenta y genera una clave de API.

  2. Ejecuta el comando /connect y busca Cortecs.

    /connect

  3. Ingresa tu clave de API de Cortecs.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo como Kimi K2 Instruct.

    /models

DeepSeek

  1. Dirígete a la consola de DeepSeek (opens in a new tab), crea una cuenta y haz clic en Create new API key.

  2. Ejecuta el comando /connect y busca DeepSeek.

    /connect

  3. Ingresa tu clave de API de DeepSeek.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo de DeepSeek como DeepSeek V4 Pro.

    /models

Deep Infra

  1. Dirígete al panel de Deep Infra (opens in a new tab), crea una cuenta y genera una clave de API.

  2. Ejecuta el comando /connect y busca Deep Infra.

    /connect

  3. Ingresa tu clave de API de Deep Infra.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo.

    /models

DigitalOcean

El Inference Engine (opens in a new tab) de DigitalOcean proporciona acceso a modelos abiertos como GPT-OSS, Llama, Qwen y DeepSeek, además de Inference Routers (opens in a new tab) personalizados que enrutan cada solicitud al modelo más barato, más rápido o más adecuado para una tarea.

OpenCode admite dos métodos de autenticación:

  • OAuth (Recomendado) — Inicia sesión en tu cuenta de DigitalOcean; OpenCode crea automáticamente una Model Access Key y descubre tus Models e Inference Routers disponibles.
  • Model Access Key — Pega una clave existente desde la consola de DigitalOcean.

OAuth (Recomendado)

  1. Ejecuta el comando /connect y busca DigitalOcean.

    /connect

  2. Selecciona Login with DigitalOcean.

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

  3. Tu navegador se abre para autorizar OpenCode. Inicia sesión y aprueba.

    Nota: OpenCode crea una Model Access Key llamada opencode-oauth-<timestamp> en tu cuenta de DigitalOcean. Puedes rotarla o revocarla desde la página Model Access Keys en la sección "Manage" de la consola de DigitalOcean, en Inference.

  4. Ejecuta el comando /models. Tus Inference Routers aparecen con el formato router: en la selección de modelos.

    /models

  5. Para captar los Inference Routers recién creados, vuelve a ejecutar /connect y selecciona DigitalOcean de nuevo.

Usar una Model Access Key

Si prefieres pegar una clave directamente:

  1. Dirígete a la página Manage en la sección Inference de la consola de DigitalOcean (opens in a new tab) y crea una nueva clave.

  2. Ejecuta el comando /connect y selecciona DigitalOcean, luego Paste Model Access Key.

    ┌ Enter your DigitalOcean Model Access Key
│
│
└ enter

    Nota: Los Inference Routers no se descubren automáticamente con este método. Para mostrarlos en el selector de modelos, inicia sesión vía OAuth en su lugar.

  3. Ejecuta el comando /models para seleccionar un modelo.

    /models

Variable de entorno

Alternativamente, establece tu Model Access Key como una variable de entorno.

export DIGITALOCEAN_ACCESS_TOKEN=your-model-access-key

Inference Routers

Los Inference Routers te permiten definir una política de enrutamiento entre varios modelos — eligiendo el modelo más barato, más rápido o más apropiado por solicitud según la tarea. Después de OAuth, OpenCode muestra cada router como router:<router-name> en el selector de modelos.

Seleccionar un modelo de router es un reemplazo directo de cualquier otro modelo — OpenCode reenvía tu solicitud y DigitalOcean elige el modelo subyacente según la política de tu router. Más información sobre los Inference Routers (opens in a new tab)

FrogBot

  1. Dirígete al panel de FrogBot (opens in a new tab), crea una cuenta y genera una clave de API.

  2. Ejecuta el comando /connect y busca FrogBot.

    /connect

  3. Ingresa tu clave de API de FrogBot.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo.

    /models

Fireworks AI

  1. Dirígete a la consola de Fireworks AI (opens in a new tab), crea una cuenta y haz clic en Create API Key.

  2. Ejecuta el comando /connect y busca Fireworks AI.

    /connect

  3. Ingresa tu clave de API de Fireworks AI.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo como Kimi K2 Instruct.

    /models

GitLab Duo

Precaución: El soporte de GitLab Duo en OpenCode es experimental. Las funciones, la configuración y el comportamiento pueden cambiar en futuras versiones.

OpenCode se integra con la GitLab Duo Agent Platform (opens in a new tab), proporcionando chat agéntico impulsado por IA con capacidades nativas de llamada a herramientas.

Nota: La GitLab Duo Agent Platform requiere una suscripción Premium o Ultimate de GitLab. Está disponible en GitLab.com y en GitLab autogestionado. Consulta los requisitos previos de la GitLab Duo Agent Platform (opens in a new tab) para ver todos los requisitos.

  1. Ejecuta el comando /connect y selecciona GitLab.

    /connect

  2. Elige tu método de autenticación:

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

    Usar OAuth (Recomendado)

    Selecciona OAuth y tu navegador se abrirá para la autorización.

    Usar un Personal Access Token

    1. Ve a GitLab User Settings > Access Tokens (opens in a new tab)
    2. Haz clic en Add new token
    3. Nombre: OpenCode , Ámbitos: api
    4. Copia el token (empieza con glpat- )
    5. Ingrésalo en la terminal

  3. Ejecuta el comando /models para ver los modelos disponibles.

    /models

    Hay tres modelos basados en Claude disponibles:

    • duo-chat-haiku-4-5 (Predeterminado) - Respuestas rápidas para tareas cortas
    • duo-chat-sonnet-4-5 - Rendimiento equilibrado para la mayoría de los flujos de trabajo
    • duo-chat-opus-4-5 - El más capaz para análisis complejos

Nota: También puedes especificar la variable de entorno 'GITLAB_TOKEN' si no quieres almacenar el token en el almacenamiento de auth de opencode.

GitLab autogestionado

Nota: OpenCode usa un modelo pequeño para algunas tareas de IA como generar el título de la sesión. Está configurado para usar gpt-5-nano por defecto, alojado por Zen. Para limitar OpenCode a usar únicamente tu propia instancia alojada en GitLab, agrega lo siguiente a tu archivo opencode.json. También se recomienda deshabilitar el compartir sesiones.

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

Para instancias de GitLab autogestionadas:

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

Si tu instancia ejecuta un AI Gateway personalizado:

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

O agrégalo a tu perfil de bash:

~/.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: Tu administrador de GitLab debe:

  1. Activar GitLab Duo (opens in a new tab) para el usuario, grupo o instancia
  2. Activar la Agent Platform (opens in a new tab) (GitLab 18.8+) o habilitar las funciones beta y experimentales (opens in a new tab) (GitLab 18.7 y anteriores)
  3. Para autogestionado, configurar tu instancia (opens in a new tab)
OAuth para instancias autogestionadas

Para que OAuth funcione en tu instancia autogestionada, necesitas crear una nueva aplicación (Settings → Applications) con la URL de callback http://127.0.0.1:8080/callback y los siguientes ámbitos:

  • api (Acceder a la API en tu nombre)
  • read_user (Leer tu información personal)
  • read_repository (Permite acceso de solo lectura al repositorio)

Luego expón el ID de la aplicación como una variable de entorno:

export GITLAB_OAUTH_CLIENT_ID=your_application_id_here

Más documentación en la página de inicio de opencode-gitlab-auth (opens in a new tab).

Configuración

Personaliza a través de opencode.json:

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

Los modelos de flujo de trabajo de DAP proporcionan una ruta de ejecución alternativa que enruta las llamadas a herramientas a través del Duo Workflow Service (DWS) de GitLab en lugar del chat agéntico estándar. Cuando se selecciona un modelo duo-workflow-*, OpenCode hará lo siguiente:

  1. Descubrir los modelos disponibles desde tu namespace de GitLab
  2. Presentar un selector si hay varios modelos disponibles
  3. Almacenar en caché el modelo seleccionado en disco para arranques posteriores rápidos
  4. Enrutar las solicitudes de ejecución de herramientas a través del sistema de herramientas con permisos de OpenCode

Los modelos de flujo de trabajo de DAP disponibles siguen la convención de nomenclatura duo-workflow-* y se descubren dinámicamente desde tu instancia de GitLab.

Herramientas de la API de GitLab (Opcional, pero muy recomendado)

Para acceder a las herramientas de GitLab (merge requests, issues, pipelines, CI/CD, etc.):

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

Este plugin proporciona capacidades completas de gestión de repositorios de GitLab, incluyendo revisiones de MR, seguimiento de issues, monitoreo de pipelines y más.

GitHub Copilot

Para usar tu suscripción de GitHub Copilot con opencode:

Nota: Algunos modelos pueden necesitar una suscripción Pro+ (opens in a new tab) para usarse.

  1. Ejecuta el comando /connect y busca GitHub Copilot.

    /connect

  2. Navega a github.com/login/device (opens in a new tab) e ingresa el código.

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

  3. Ahora ejecuta el comando /models para seleccionar el modelo que quieras.

    /models

Google Vertex AI

Para usar Google Vertex AI con OpenCode:

  1. Dirígete al Model Garden en la Google Cloud Console y revisa los modelos disponibles en tu región.

    Nota: Necesitas tener un proyecto de Google Cloud con la API de Vertex AI habilitada.

  2. Establece las variables de entorno requeridas:

    • GOOGLE_CLOUD_PROJECT : El ID de tu proyecto de Google Cloud

    • VERTEX_LOCATION (opcional): La región para Vertex AI (por defecto global )

    • Autenticación (elige una):

      • GOOGLE_APPLICATION_CREDENTIALS : Ruta a tu archivo de clave JSON de la cuenta de servicio
      • Autenticarse usando la CLI de gcloud: gcloud auth application-default login

    Establécelas mientras ejecutas opencode.

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

    O agrégalas a tu perfil de bash.

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

Consejo: La región global mejora la disponibilidad y reduce los errores sin costo adicional. Usa endpoints regionales (por ejemplo, us-central1) para los requisitos de residencia de datos. Más información (opens in a new tab)

  1. Ejecuta el comando /models para seleccionar el modelo que quieras.

    /models

Groq

  1. Dirígete a la consola de Groq (opens in a new tab), haz clic en Create API Key y copia la clave.

  2. Ejecuta el comando /connect y busca Groq.

    /connect

  3. Ingresa la clave de API del proveedor.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar el que quieras.

    /models

Hugging Face

Hugging Face Inference Providers (opens in a new tab) proporciona acceso a modelos abiertos compatibles con más de 17 proveedores.

  1. Dirígete a la configuración de Hugging Face (opens in a new tab) para crear un token con permiso para hacer llamadas a Inference Providers.

  2. Ejecuta el comando /connect y busca Hugging Face.

    /connect

  3. Ingresa tu token de Hugging Face.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo como Kimi-K2-Instruct o GLM-4.6.

    /models

Helicone

Helicone (opens in a new tab) es una plataforma de observabilidad de LLM que proporciona registro, monitoreo y análisis para tus aplicaciones de IA. El Helicone AI Gateway enruta tus solicitudes al proveedor apropiado automáticamente según el modelo.

  1. Dirígete a Helicone (opens in a new tab), crea una cuenta y genera una clave de API desde tu panel.

  2. Ejecuta el comando /connect y busca Helicone.

    /connect

  3. Ingresa tu clave de API de Helicone.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo.

    /models

Para más proveedores y funciones avanzadas como almacenamiento en caché y limitación de tasa, consulta la documentación de Helicone (opens in a new tab).

Configuraciones opcionales

En caso de que veas una función o modelo de Helicone que no se configure automáticamente a través de opencode, siempre puedes configurarlo tú mismo.

Aquí está el Model Directory de Helicone (opens in a new tab), lo necesitarás para obtener los IDs de los modelos que quieres agregar.

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

Encabezados personalizados

Helicone admite encabezados personalizados para funciones como almacenamiento en caché, seguimiento de usuarios y gestión de sesiones. Agrégalos a la configuración de tu proveedor 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",
        },
      },
    },
  },
}
Seguimiento de sesiones

La función Sessions (opens in a new tab) de Helicone te permite agrupar solicitudes de LLM relacionadas. Usa el plugin opencode-helicone-session (opens in a new tab) para registrar automáticamente cada conversación de OpenCode como una sesión en Helicone.

npm install -g opencode-helicone-session

Agrégalo a tu configuración.

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

El plugin inyecta los encabezados Helicone-Session-Id y Helicone-Session-Name en tus solicitudes. En la página Sessions de Helicone, verás cada conversación de OpenCode listada como una sesión separada.

Encabezados comunes de Helicone
EncabezadoDescripción
Helicone-Cache-EnabledHabilitar el almacenamiento en caché de respuestas (true/false)
Helicone-User-IdRastrear métricas por usuario
Helicone-Property-[Name]Agregar propiedades personalizadas (por ejemplo, Helicone-Property-Environment)
Helicone-Prompt-IdAsociar solicitudes con versiones de prompts

Consulta el Helicone Header Directory (opens in a new tab) para todos los encabezados disponibles.

llama.cpp

Puedes configurar opencode para usar modelos locales a través de la utilidad llama-server de 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
          }
        }
      }
    }
  }
}

En este ejemplo:

  • llama.cpp es el ID de proveedor personalizado. Puede ser cualquier cadena que quieras.
  • npm especifica el paquete que se usará para este proveedor. Aquí, @ai-sdk/openai-compatible se usa para cualquier API compatible con OpenAI.
  • name es el nombre de visualización del proveedor en la UI.
  • options.baseURL es el endpoint del servidor local.
  • models es un mapa de IDs de modelo a sus configuraciones. El nombre del modelo se mostrará en la lista de selección de modelos.

IO.NET

IO.NET ofrece 17 modelos optimizados para varios casos de uso:

  1. Dirígete a la consola de IO.NET (opens in a new tab), crea una cuenta y genera una clave de API.

  2. Ejecuta el comando /connect y busca IO.NET.

    /connect

  3. Ingresa tu clave de API de IO.NET.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo.

    /models

LM Studio

Puedes configurar opencode para usar modelos locales a través de 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)"
        }
      }
    }
  }
}

En este ejemplo:

  • lmstudio es el ID de proveedor personalizado. Puede ser cualquier cadena que quieras.
  • npm especifica el paquete que se usará para este proveedor. Aquí, @ai-sdk/openai-compatible se usa para cualquier API compatible con OpenAI.
  • name es el nombre de visualización del proveedor en la UI.
  • options.baseURL es el endpoint del servidor local.
  • models es un mapa de IDs de modelo a sus configuraciones. El nombre del modelo se mostrará en la lista de selección de modelos.

Moonshot AI

Para usar Kimi K2 de Moonshot AI:

  1. Dirígete a la consola de Moonshot AI (opens in a new tab), crea una cuenta y haz clic en Create API key.

  2. Ejecuta el comando /connect y busca Moonshot AI.

    /connect

  3. Ingresa tu clave de API de Moonshot.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar Kimi K2.

    /models

MiniMax

  1. Dirígete a la MiniMax API Console (opens in a new tab), crea una cuenta y genera una clave de API.

  2. Ejecuta el comando /connect y busca MiniMax.

    /connect

  3. Ingresa tu clave de API de MiniMax.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo como M2.1.

    /models

NVIDIA

NVIDIA proporciona acceso a los modelos Nemotron y muchos otros modelos abiertos a través de build.nvidia.com (opens in a new tab) de forma gratuita.

  1. Dirígete a build.nvidia.com (opens in a new tab), crea una cuenta y genera una clave de API.

  2. Ejecuta el comando /connect y busca NVIDIA.

    /connect

  3. Ingresa tu clave de API de NVIDIA.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo como nemotron-3-super-120b-a12b.

    /models

On-Prem / NIM

También puedes usar modelos de NVIDIA localmente vía NVIDIA NIM (opens in a new tab) estableciendo una URL base personalizada.

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

Variable de entorno

Alternativamente, establece tu clave de API como una variable de entorno.

export NVIDIA_API_KEY=nvapi-your-key-here

Nebius Token Factory

  1. Dirígete a la consola de Nebius Token Factory (opens in a new tab), crea una cuenta y haz clic en Add Key.

  2. Ejecuta el comando /connect y busca Nebius Token Factory.

    /connect

  3. Ingresa tu clave de API de Nebius Token Factory.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo como Kimi K2 Instruct.

    /models

Ollama

Puedes configurar opencode para usar modelos locales a través de Ollama.

Consejo: Ollama puede configurarse automáticamente para OpenCode. Consulta la documentación de integración de Ollama (opens in a new tab) para más detalles.

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

En este ejemplo:

  • ollama es el ID de proveedor personalizado. Puede ser cualquier cadena que quieras.
  • npm especifica el paquete que se usará para este proveedor. Aquí, @ai-sdk/openai-compatible se usa para cualquier API compatible con OpenAI.
  • name es el nombre de visualización del proveedor en la UI.
  • options.baseURL es el endpoint del servidor local.
  • models es un mapa de IDs de modelo a sus configuraciones. El nombre del modelo se mostrará en la lista de selección de modelos.

Consejo: Si las llamadas a herramientas no funcionan, prueba a aumentar num_ctx en Ollama. Empieza alrededor de 16k - 32k.

Ollama Cloud

Para usar Ollama Cloud con OpenCode:

  1. Dirígete a https://ollama.com/ (opens in a new tab) e inicia sesión o crea una cuenta.

  2. Navega a Settings > Keys y haz clic en Add API Key para generar una nueva clave de API.

  3. Copia la clave de API para usarla en OpenCode.

  4. Ejecuta el comando /connect y busca Ollama Cloud.

    /connect

  5. Ingresa tu clave de API de Ollama Cloud.

    ┌ API key
│
│
└ enter

  6. Importante: Antes de usar modelos en la nube en OpenCode, debes descargar la información del modelo localmente:

    ollama pull gpt-oss:20b-cloud

  7. Ejecuta el comando /models para seleccionar tu modelo de Ollama Cloud.

    /models

OpenAI

Recomendamos registrarse en ChatGPT Plus o Pro (opens in a new tab).

  1. Una vez que te hayas registrado, ejecuta el comando /connect y selecciona OpenAI.

    /connect

  2. Aquí puedes seleccionar la opción ChatGPT Plus/Pro y abrirá tu navegador y te pedirá que te autentiques.

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

  3. Ahora todos los modelos de OpenAI deberían estar disponibles cuando uses el comando /models.

    /models
Usar claves de API

Si ya tienes una clave de API, puedes seleccionar Manually enter API Key y pegarla en tu terminal.

OpenCode Zen

OpenCode Zen es una lista de modelos probados y verificados proporcionados por el equipo de OpenCode. Más información.

  1. Inicia sesión en OpenCode Zen (opens in a new tab) y haz clic en Create API Key.

  2. Ejecuta el comando /connect y busca OpenCode Zen.

    /connect

  3. Ingresa tu clave de API de OpenCode.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo como Qwen 3 Coder 480B.

    /models

OpenRouter

  1. Dirígete al panel de OpenRouter (opens in a new tab), haz clic en Create API Key y copia la clave.

  2. Ejecuta el comando /connect y busca OpenRouter.

    /connect

  3. Ingresa la clave de API del proveedor.

    ┌ API key
│
│
└ enter

  4. Muchos modelos de OpenRouter se precargan por defecto, ejecuta el comando /models para seleccionar el que quieras.

    /models

    También puedes agregar modelos adicionales a través de tu configuración de opencode.

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

  5. También puedes personalizarlos a través de tu configuración de opencode. Aquí hay un ejemplo de cómo especificar un proveedor

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

LLM Gateway

  1. Dirígete al panel de LLM Gateway (opens in a new tab), haz clic en Create API Key y copia la clave.

  2. Ejecuta el comando /connect y busca LLM Gateway.

    /connect

  3. Ingresa la clave de API del proveedor.

    ┌ API key
│
│
└ enter

  4. Muchos modelos de LLM Gateway se precargan por defecto, ejecuta el comando /models para seleccionar el que quieras.

    /models

    También puedes agregar modelos adicionales a través de tu configuración de opencode.

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

  5. También puedes personalizarlos a través de tu configuración de opencode. Aquí hay un ejemplo de cómo especificar un proveedor

    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

SAP AI Core proporciona acceso a más de 40 modelos de OpenAI, Anthropic, Google, Amazon, Meta, Mistral y AI21 a través de una plataforma unificada.

  1. Ve a tu SAP BTP Cockpit (opens in a new tab), navega a tu instancia de servicio de SAP AI Core y crea una service key.

    Consejo: La service key es un objeto JSON que contiene clientid, clientsecret, url y serviceurls.AI_API_URL. Puedes encontrar tu instancia de AI Core en Services > Instances and Subscriptions en el BTP Cockpit.

  2. Ejecuta el comando /connect y busca SAP AI Core.

    /connect

  3. Ingresa tu JSON de service key.

    ┌ Service key
│
│
└ enter

    O establece la variable de entorno AICORE_SERVICE_KEY:

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

    O agrégala a tu perfil de bash:

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

  4. Opcionalmente, establece el deployment ID y el resource group:

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

    Nota: Estos ajustes son opcionales y deben configurarse según tu configuración de SAP AI Core.

  5. Ejecuta el comando /models para seleccionar entre los más de 40 modelos disponibles.

    /models

STACKIT

STACKIT AI Model Serving proporciona un entorno de alojamiento soberano totalmente gestionado para modelos de IA, centrándose en LLM como Llama, Mistral y Qwen, con máxima soberanía de datos sobre infraestructura europea.

  1. Dirígete al STACKIT Portal (opens in a new tab), navega a AI Model Serving y crea un auth token para tu proyecto.

    Consejo: Necesitas una cuenta de cliente de STACKIT, una cuenta de usuario y un proyecto antes de crear auth tokens.

  2. Ejecuta el comando /connect y busca STACKIT.

    /connect

  3. Ingresa tu auth token de STACKIT AI Model Serving.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar entre los modelos disponibles como Qwen3-VL 235B o Llama 3.3 70B.

    /models

OVHcloud AI Endpoints

  1. Dirígete al panel de OVHcloud (opens in a new tab). Navega a la sección Public Cloud, AI & Machine Learning > AI Endpoints y en la pestaña API Keys, haz clic en Create a new API key.

  2. Ejecuta el comando /connect y busca OVHcloud AI Endpoints.

    /connect

  3. Ingresa tu clave de API de OVHcloud AI Endpoints.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo como gpt-oss-120b.

    /models

Scaleway

Para usar Scaleway Generative APIs (opens in a new tab) con Opencode:

  1. Dirígete a la configuración de IAM de la Scaleway Console (opens in a new tab) para generar una nueva clave de API.

  2. Ejecuta el comando /connect y busca Scaleway.

    /connect

  3. Ingresa tu clave de API de Scaleway.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo como devstral-2-123b-instruct-2512 o gpt-oss-120b.

    /models

Together AI

  1. Dirígete a la consola de Together AI (opens in a new tab), crea una cuenta y haz clic en Add Key.

  2. Ejecuta el comando /connect y busca Together AI.

    /connect

  3. Ingresa tu clave de API de Together AI.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo como Kimi K2 Instruct.

    /models

Venice AI

  1. Dirígete a la consola de Venice AI (opens in a new tab), crea una cuenta y genera una clave de API.

  2. Ejecuta el comando /connect y busca Venice AI.

    /connect

  3. Ingresa tu clave de API de Venice AI.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo como Llama 3.3 70B.

    /models

Vercel AI Gateway

Vercel AI Gateway te permite acceder a modelos de OpenAI, Anthropic, Google, xAI y más a través de un endpoint unificado. Los modelos se ofrecen al precio de lista sin margen adicional.

  1. Dirígete al panel de Vercel (opens in a new tab), navega a la pestaña AI Gateway y haz clic en API keys para crear una nueva clave de API.

  2. Ejecuta el comando /connect y busca Vercel AI Gateway.

    /connect

  3. Ingresa tu clave de API de Vercel AI Gateway.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo.

    /models

También puedes personalizar los modelos a través de tu configuración de opencode. Aquí hay un ejemplo de cómo especificar el orden de enrutamiento de proveedores.

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

Algunas opciones útiles de enrutamiento:

OpciónDescripción
orderSecuencia de proveedores a probar
onlyRestringir a proveedores específicos
zeroDataRetentionUsar solo proveedores con políticas de retención de datos cero

xAI

Tres formas de autenticarse: una suscripción de SuperGrok vía OAuth en el navegador, la misma suscripción de SuperGrok vía un flujo de device-code sin navegador (para VPS / SSH / Docker), o una clave de API de pago por uso de la consola de xAI.

Opción A — SuperGrok OAuth (inicio de sesión por navegador)

  1. Ejecuta el comando /connect y busca xAI.

    /connect

  2. Selecciona xAI Grok OAuth (SuperGrok Subscription). OpenCode abre la pantalla de consentimiento de xAI en tu navegador y espera el callback en http://127.0.0.1:56121/callback.

  3. Ejecuta el comando /models para seleccionar un modelo Grok.

    /models

OpenCode actualiza el token de acceso OAuth automáticamente. Funciona cualquier plan de Grok o X Premium que incluya acceso a la API de Grok; no necesitas una XAI_API_KEY separada.

Opción B — SuperGrok device-code (sin navegador / servidor remoto / VPS)

Usa esto cuando OpenCode se ejecuta en un lugar donde un navegador no puede alcanzar la redirección de loopback: un VPS, una máquina de desarrollo remota por SSH, dentro de Docker, en CI, etc. No se abre ningún puerto de callback en el host que ejecuta OpenCode — en su lugar, xAI le entrega a la CLI un código corto que escribes en un navegador en cualquier otro dispositivo (portátil, teléfono, ...).

  1. Ejecuta el comando /connect en el host remoto y busca xAI.

    /connect

  2. Selecciona xAI Grok OAuth (Headless / Remote / VPS). OpenCode imprime una URL de verificación y un código de usuario corto.

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

  3. Abre la URL en un dispositivo que tenga un navegador (tu portátil o teléfono), ingresa el código y aprueba la pantalla de consentimiento. OpenCode sondea el endpoint de tokens de xAI y almacena los tokens OAuth resultantes una vez que apruebas. La actualización de tokens funciona igual que en la Opción A.

Opción C — Clave de API

  1. Dirígete a la consola de xAI (opens in a new tab), crea una cuenta y genera una clave de API.

  2. Ejecuta el comando /connect y busca xAI.

    /connect

  3. Selecciona Manually enter API Key y pega tu clave de API de xAI.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo como Grok Beta.

    /models

Z.AI

  1. Dirígete a la consola de la API de Z.AI (opens in a new tab), crea una cuenta y haz clic en Create a new API key.

  2. Ejecuta el comando /connect y busca Z.AI.

    /connect

    Si estás suscrito al GLM Coding Plan, selecciona Z.AI Coding Plan.

  3. Ingresa tu clave de API de Z.AI.

    ┌ API key
│
│
└ enter

  4. Ejecuta el comando /models para seleccionar un modelo como GLM-4.7.

    /models

ZenMux

  1. Dirígete al panel de ZenMux (opens in a new tab), haz clic en Create API Key y copia la clave.

  2. Ejecuta el comando /connect y busca ZenMux.

    /connect

  3. Ingresa la clave de API del proveedor.

    ┌ API key
│
│
└ enter

  4. Muchos modelos de ZenMux se precargan por defecto, ejecuta el comando /models para seleccionar el que quieras.

    /models

    También puedes agregar modelos adicionales a través de tu configuración de opencode.

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

Proveedor personalizado

Para agregar cualquier proveedor compatible con OpenAI que no esté listado en el comando /connect:

Consejo: Puedes usar cualquier proveedor compatible con OpenAI con opencode. La mayoría de los proveedores de IA modernos ofrecen APIs compatibles con OpenAI.

  1. Ejecuta el comando /connect y desplázate hacia abajo hasta Other.

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

  2. Ingresa un ID único para el proveedor.

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

    Nota: Elige un ID memorable, lo usarás en tu archivo de configuración.

  3. Ingresa tu clave de API para el proveedor.

    $ /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 actualiza tu archivo opencode.json en el directorio de tu proyecto:

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

    Estas son las opciones de configuración:

    • npm : Paquete del AI SDK a usar, @ai-sdk/openai-compatible para proveedores compatibles con OpenAI (para /v1/chat/completions ). Si tu proveedor/modelo usa /v1/responses , usa @ai-sdk/openai .
    • name : Nombre de visualización en la UI.
    • models : Modelos disponibles.
    • options.baseURL : URL del endpoint de la API.
    • options.apiKey : Opcionalmente establece la clave de API, si no usas auth.
    • options.headers : Opcionalmente establece encabezados personalizados.

    Más sobre las opciones avanzadas en el ejemplo siguiente.

  5. Ejecuta el comando /models y tu proveedor y modelos personalizados aparecerán en la lista de selección.

Ejemplo

Aquí hay un ejemplo que establece las opciones apiKey, headers y limit del 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
          }
        }
      }
    }
  }
}

Detalles de configuración:

  • apiKey : Se establece usando la sintaxis de variable env, más información .
  • headers : Encabezados personalizados enviados con cada solicitud.
  • limit.context : Máximo de tokens de entrada que el modelo acepta.
  • limit.output : Máximo de tokens que el modelo puede generar.

Los campos limit permiten a OpenCode entender cuánto contexto te queda. Los proveedores estándar obtienen estos datos de models.dev automáticamente.

Solución de problemas

Si tienes problemas para configurar un proveedor, revisa lo siguiente:

  1. Revisa la configuración de auth: Ejecuta opencode auth list para ver si las credenciales del proveedor están agregadas a tu configuración. Esto no aplica a proveedores como Amazon Bedrock, que dependen de variables de entorno para su auth.

  2. Para proveedores personalizados, revisa la configuración de opencode y:

    • Asegúrate de que el ID de proveedor usado en el comando /connect coincida con el ID en tu configuración de opencode.
    • Se usa el paquete npm correcto para el proveedor. Por ejemplo, usa @ai-sdk/cerebras para Cerebras. Y para todos los demás proveedores compatibles con OpenAI, usa @ai-sdk/openai-compatible (para /v1/chat/completions ); si un modelo usa /v1/responses , usa @ai-sdk/openai . Para configuraciones mixtas bajo un mismo proveedor, puedes anular por modelo mediante provider.npm .
    • Revisa que se use el endpoint de API correcto en el campo options.baseURL.
ConfiguraciónRed