path: root/packages/web/src/content/docs/es/providers.mdx

---
title: Proveedores
description: Usando cualquier proveedor LLM en OpenCode.
---

import config from "../../../../config.mjs"
export const console = config.console

OpenCode usa el [AI SDK](https://ai-sdk.dev/) y [Models.dev](https://models.dev) para admitir **75+ proveedores LLM** y admite la ejecución de modelos locales.

Para agregar un proveedor necesita:

1. Agregue las claves API para el proveedor usando el comando `/connect`.
2. Configure el proveedor en su configuración OpenCode.

---

### Credenciales

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

---

### Configuración

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

---

#### URL base

Puede personalizar la URL base para cualquier proveedor configurando la opción `baseURL`. Esto resulta útil cuando se utilizan servicios proxy o puntos finales personalizados.

```json title="opencode.json" {6}
{
  "$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 OpenCode que han sido
probado y verificado para funcionar bien con OpenCode. [Más información](/docs/zen).

:::tip
Si eres nuevo, te recomendamos comenzar con OpenCode Zen.
:::

1. Ejecute el comando `/connect` en TUI, seleccione opencode y diríjase a [opencode.ai/auth](https://opencode.ai/auth).

   ```txt
   /connect
   ```

2. Inicie sesión, agregue sus datos de facturación y copie su clave API.

3. Pega tu clave API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

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

   ```txt
   /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 brinda acceso confiable a modelos de codificación abiertos populares proporcionados por el equipo de OpenCode que han sido
probado y verificado para funcionar bien con OpenCode.

1. Ejecute el comando `/connect` en TUI, seleccione `OpenCode Go` y diríjase a [opencode.ai/auth](https://opencode.ai/zen).

   ```txt
   /connect
   ```

2. Inicie sesión, agregue sus datos de facturación y copie su clave API.

3. Pegue su clave API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

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

   ```txt
   /models
   ```

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

---

## Directorio

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

:::note
¿No ves un proveedor aquí? Envíe un PR.
:::

---

### 302.AI

1. Dirígete a la [consola 302.AI](https://302.ai/), crea una cuenta y genera una clave API.

2. Ejecute el comando `/connect` y busque **302.AI**.

   ```txt
   /connect
   ```

3. Ingrese su clave 302.AI API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo.

   ```txt
   /models
   ```

---

### Amazon Bedrock

Para usar Amazon Bedrock con OpenCode:

1. Dirígete al **Catálogo de modelos** en la consola Amazon Bedrock y solicita
   Accede a los modelos que desees.

   :::consejo
   Necesita tener acceso al modelo que desea en Amazon Bedrock.
   :::

2. **Configure la autenticación** utilizando uno de los siguientes métodos:

   #### Variables de entorno (Inicio rápido)

   Establezca una de estas variables de entorno mientras ejecuta opencode:

   ```bash
   # Option 1: Using AWS access keys
   AWS_ACCESS_KEY_ID=XXX AWS_SECRET_ACCESS_KEY=YYY opencode

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

   # Option 3: Using Bedrock bearer token
   AWS_BEARER_TOKEN_BEDROCK=XXX opencode
   ```

   O agrégalos a tu perfil de bash:

   ```bash title="~/.bash_profile"
   export AWS_PROFILE=my-dev-profile
   export AWS_REGION=us-east-1
   ```

   #### Archivo de configuración (recomendado)

   Para una configuración persistente o específica del proyecto, utilice `opencode.json`:

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

   **Opciones disponibles:**
   - `region` - AWS región (p. ej., `us-east-1`, `eu-west-1`)
   - `profile` - AWS perfil con nombre de `~/.aws/credentials`
   - `endpoint`: URL de punto de enlace personalizada para puntos de enlace de la VPC (alias para la opción genérica `baseURL`)

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

   #### Avanzado: puntos finales de la VPC

   Si utiliza puntos de enlace de VPC para Bedrock:

   ```json title="opencode.json"
   {
     "$schema": "https://opencode.ai/config.json",
     "provider": {
       "amazon-bedrock": {
         "options": {
           "region": "us-east-1",
           "profile": "production",
           "endpoint": "https://bedrock-runtime.us-east-1.vpce-xxxxx.amazonaws.com"
         }
       }
     }
   }
   ```

   :::nota
   La opción `endpoint` es un alias para la opción genérica `baseURL`, que utiliza terminología específica de AWS. Si se especifican `endpoint` y `baseURL`, `endpoint` tiene prioridad.
   :::

   #### Métodos de autenticación
   - **`AWS_ACCESS_KEY_ID` / `AWS_SECRET_ACCESS_KEY`**: Crear un usuario de IAM y generar claves de acceso en la Consola AWS
   - **`AWS_PROFILE`**: Utilice perfiles con nombre de `~/.aws/credentials`. Primero configure con `aws configure --profile my-profile` o `aws sso login`
   - **`AWS_BEARER_TOKEN_BEDROCK`**: Genera claves API a largo plazo desde la consola Amazon Bedrock
   - **`AWS_WEB_IDENTITY_TOKEN_FILE` / `AWS_ROLE_ARN`**: Para EKS IRSA (Roles IAM para Cuentas de Servicio) u otros entornos de Kubernetes con federación OIDC. Kubernetes inyecta automáticamente estas variables de entorno cuando se utilizan anotaciones de cuentas de servicio.

   #### Prioridad de autenticación

   Amazon Bedrock utiliza la siguiente prioridad de autenticación:
   1. **Bearer token** - variable de entorno `AWS_BEARER_TOKEN_BEDROCK` o token del comando `/connect`
   2. **AWS Cadena de credenciales**: perfil, claves de acceso, credenciales compartidas, roles de IAM, tokens de identidad web (EKS IRSA), metadatos de instancia

   :::nota
   Cuando se define un bearer token (a traves de `/connect` o `AWS_BEARER_TOKEN_BEDROCK`), tiene prioridad sobre todos los metodos de credenciales de AWS, incluidos los perfiles configurados.
   :::

3. Ejecute el comando `/models` para seleccionar el modelo que desee.

   ```txt
   /models
   ```

:::note
Para perfiles de inferencia personalizados, utilice el modelo y el nombre del proveedor en la clave y establezca la propiedad `id` en arn. Esto garantiza un almacenamiento en caché correcto:

```json title="opencode.json"
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "amazon-bedrock": {
      // ...
      "models": {
        "anthropic-claude-sonnet-4.5": {
          "id": "arn:aws:bedrock:us-east-1:xxx:application-inference-profile/yyy"
        }
      }
    }
  }
}
```

:::

---

### Anthropic

1. Una vez que se haya registrado, ejecute el comando `/connect` y seleccione Anthropic.

   ```txt
   /connect
   ```

2. Aquí puedes seleccionar la opción **Claude Pro/Max** y se abrirá tu navegador.
   y pedirle que se autentique.

   ```txt
   ┌ Select auth method
   │
   │ Claude Pro/Max
   │ Create an API Key
   │ Manually enter API Key
   └
   ```

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

   ```txt
   /models
   ```

:::info
El uso de su suscripción Claude Pro/Max en OpenCode no está oficialmente respaldado por [Anthropic](https://anthropic.com).
:::

##### Usando las teclas API

También puede seleccionar **Crear una clave API** si no tiene una suscripción Pro/Max. También abrirá su navegador y le pedirá que inicie sesión en Anthropic y le dará un código que puede pegar en su terminal.

O si ya tienes una clave API, puedes seleccionar **Ingresar manualmente la clave API** y pegarla en tu terminal.

---

### Atomic Chat

Puedes configurar opencode para usar modelos locales mediante [Atomic Chat](https://atomic.chat), una aplicación de escritorio que ejecuta LLMs locales detrás de un servidor API compatible con OpenAI (endpoint por defecto `http://127.0.0.1:1337/v1`).

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

En este ejemplo:

- `atomic-chat` es el identificador personalizado del proveedor. Puede ser cualquier cadena que quieras.
- `npm` especifica el paquete que se usará para este proveedor. Aquí se usa `@ai-sdk/openai-compatible` para cualquier API compatible con OpenAI.
- `name` es el nombre que se muestra para el proveedor en la interfaz.
- `options.baseURL` es el endpoint del servidor local. Cambia el host y el puerto según tu configuración de Atomic Chat.
- `models` es un mapa de IDs de modelos a sus nombres de pantalla. 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.

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

---

### Azure OpenAI

:::note
Si encuentra errores del tipo "Lo siento, pero no puedo ayudar con esa solicitud", intente cambiar el filtro de contenido de **DefaultV2** a **Default** en su recurso de Azure.
:::

1. Diríjase al [portal de Azure](https://portal.azure.com/) y cree un recurso **Azure OpenAI**. Necesitarás:
   - **Nombre del recurso**: esto pasa a formar parte de su punto final API (`https://RESOURCE_NAME.openai.azure.com/`)
   - **Clave API**: `KEY 1` o `KEY 2` de su recurso

2. Vaya a [Azure AI Foundry](https://ai.azure.com/) e implemente un modelo.

   :::nota
   El nombre de la implementación debe coincidir con el nombre del modelo para que opencode funcione correctamente.
   :::

3. Ejecute el comando `/connect` y busque **Azure**.

   ```txt
   /connect
   ```

4. Ingrese su clave API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

5. Configure el nombre de su recurso como una variable de entorno:

   ```bash
   AZURE_RESOURCE_NAME=XXX opencode
   ```

   O agrégalo a tu perfil de bash:

   ```bash title="~/.bash_profile"
   export AZURE_RESOURCE_NAME=XXX
   ```

6. Ejecute el comando `/models` para seleccionar su modelo implementado.

   ```txt
   /models
   ```

---

### Servicios cognitivos de Azure

1. Diríjase al [portal de Azure](https://portal.azure.com/) y cree un recurso **Azure OpenAI**. Necesitarás:
   - **Nombre del recurso**: esto pasa a formar parte de su punto final API (`https://AZURE_COGNITIVE_SERVICES_RESOURCE_NAME.cognitiveservices.azure.com/`)
   - **Clave API**: `KEY 1` o `KEY 2` de su recurso

2. Vaya a [Azure AI Foundry](https://ai.azure.com/) e implemente un modelo.

   :::nota
   El nombre de la implementación debe coincidir con el nombre del modelo para que opencode funcione correctamente.
   :::

3. Ejecute el comando `/connect` y busque **Azure Cognitive Services**.

   ```txt
   /connect
   ```

4. Ingrese su clave API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

5. Configure el nombre de su recurso como una variable de entorno:

   ```bash
   AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
   ```

   O agrégalo a tu perfil de bash:

   ```bash title="~/.bash_profile"
   export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX
   ```

6. Ejecute el comando `/models` para seleccionar su modelo implementado.

   ```txt
   /models
   ```

---

### Baseten

1. Dirígete a [Baseten](https://app.baseten.co/), crea una cuenta y genera una clave API.

2. Ejecute el comando `/connect` y busque **Baseten**.

   ```txt
   /connect
   ```

3. Ingrese su clave Baseten API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo.

   ```txt
   /models
   ```

---

### Cerebras

1. Dirígete a la [consola Cerebras](https://inference.cerebras.ai/), crea una cuenta y genera una clave API.

2. Ejecute el comando `/connect` y busque **Cerebras**.

   ```txt
   /connect
   ```

3. Ingrese su clave Cerebras API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo como _Qwen 3 Coder 480B_.

   ```txt
   /models
   ```

---

### Cloudflare AI Gateway

Cloudflare AI Gateway le permite acceder a modelos de OpenAI, Anthropic, Workers AI y más a través de un punto final unificado. Con [Facturación unificada](https://developers.cloudflare.com/ai-gateway/features/unified-billing/) no necesita claves API independientes para cada proveedor.

1. Dirígete al [panel de Cloudflare](https://dash.cloudflare.com/), navega hasta **AI** > **AI Gateway** y crea una nueva puerta de enlace.

2. Configure su ID de cuenta y su ID de puerta de enlace como variables de entorno.

   ```bash title="~/.bash_profile"
   export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
   export CLOUDFLARE_GATEWAY_ID=your-gateway-id
   ```

3. Ejecute el comando `/connect` y busque **Cloudflare AI Gateway**.

   ```txt
   /connect
   ```

4. Ingrese su token API de Cloudflare.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

   O configúrelo como una variable de entorno.

   ```bash title="~/.bash_profile"
   export CLOUDFLARE_API_TOKEN=your-api-token
   ```

5. Ejecute el comando `/models` para seleccionar un modelo.

   ```txt
   /models
   ```

   También puede agregar modelos a través de su configuración opencode.

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

---

### Córtecs

1. Dirígete a la [consola de Cortecs](https://cortecs.ai/), crea una cuenta y genera una clave API.

2. Ejecute el comando `/connect` y busque **Cortecs**.

   ```txt
   /connect
   ```

3. Ingrese su clave Cortecs API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo como _Kimi K2 Instruct_.

   ```txt
   /models
   ```

---

### DeepSeek

1. Dirígete a la [consola de DeepSeek](https://platform.deepseek.com/), crea una cuenta y haz clic en **Crear nueva clave API**.

2. Ejecute el comando `/connect` y busque **DeepSeek**.

   ```txt
   /connect
   ```

3. Ingrese su clave DeepSeek API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo de DeepSeek como _DeepSeek V4 Pro_.

   ```txt
   /models
   ```

---

### Deep Infra

1. Dirígete al [panel de Deep Infra](https://deepinfra.com/dash), crea una cuenta y genera una clave API.

2. Ejecute el comando `/connect` y busque **Deep Infra**.

   ```txt
   /connect
   ```

3. Ingrese su clave Deep Infra API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo.

   ```txt
   /models
   ```

---

### Firmware

1. Dirígete al [Panel de firmware](https://app.firmware.ai/signup), crea una cuenta y genera una clave API.

2. Ejecute el comando `/connect` y busque **Firmware**.

   ```txt
   /connect
   ```

3. Ingrese su clave de firmware API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo.

   ```txt
   /models
   ```

---

### Fireworks AI

1. Dirígete a la [Consola de Fireworks AI](https://app.fireworks.ai/), crea una cuenta y haz clic en **Crear clave API**.

2. Ejecute el comando `/connect` y busque **Fireworks AI**.

   ```txt
   /connect
   ```

3. Ingrese su clave API de AI de Fireworks.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo como _Kimi K2 Instruct_.

   ```txt
   /models
   ```

---

### GitLab Duo

GitLab Duo proporciona chat agente basado en IA con capacidades de llamada de herramientas nativas a través del proxy Anthropic de GitLab.

1. Ejecute el comando `/connect` y seleccione GitLab.

   ```txt
   /connect
   ```

2. Elija su método de autenticación:

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

   #### Usando OAuth (recomendado)

   Seleccione **OAuth** y su navegador se abrirá para autorización.

   #### Uso del token de acceso personal
   1. Vaya a [GitLab Configuración de usuario > Tokens de acceso](https://gitlab.com/-/user_settings/personal_access_tokens)
   2. Haga clic en **Agregar nuevo token**
   3. Nombre: `OpenCode`, Alcances: `api`
   4. Copie el token (comienza con `glpat-`)
   5. Introdúcelo en la terminal.

3. Ejecute el comando `/models` para ver los modelos disponibles.

   ```txt
   /models
   ```

   Hay tres modelos basados ​​en Claude disponibles:
   - **duo-chat-haiku-4-5** (predeterminado) - Respuestas rápidas para tareas rápidas
   - **duo-chat-sonnet-4-5** - Rendimiento equilibrado para la mayoría de los flujos de trabajo
   - **duo-chat-opus-4-5** - Más capaz para análisis complejos

:::note
También puede especificar la variable de entorno 'GITLAB_TOKEN' si no desea
para almacenar el token en el almacenamiento de autenticación opencode.
:::

##### Autohospedado GitLab

:::note[nota de cumplimiento]
OpenCode utiliza 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 de forma predeterminada, alojado por Zen. Para bloquear OpenCode
Para usar solo su propia instancia alojada en GitLab, agregue lo siguiente a su
Archivo `opencode.json`. También se recomienda desactivar el uso compartido de sesiones.

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

:::

Para instancias GitLab autohospedadas:

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

Si su instancia ejecuta una puerta de enlace AI personalizada:

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

O agregue a su perfil de bash:

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

:::note
Su administrador GitLab debe habilitar lo siguiente:

1. [Plataforma de agente Duo](https://docs.gitlab.com/user/duo_agent_platform/turn_on_off/) para el usuario, grupo o instancia
2. Indicadores de funciones (a través de la consola Rails):
   - `agent_platform_claude_code`
   - `third_party_agents_enabled`
     :::

##### OAuth para instancias autohospedadas

Para que Oauth funcione para su instancia autohospedada, debe crear
una nueva aplicación (Configuración → Aplicaciones) con el
URL de devolución de llamada `http://127.0.0.1:8080/callback` y siguientes ámbitos:

- api (Acceda al API en su nombre)
- read_user (Lee tu información personal)
- read_repository (Permite acceso de solo lectura al repositorio)

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

```bash
export GITLAB_OAUTH_CLIENT_ID=your_application_id_here
```

Más documentación en la página de inicio de [opencode-gitlab-auth](https://www.npmjs.com/package/opencode-gitlab-auth).

##### Configuración

Personalizar a través de `opencode.json`:

```json title="opencode.json"
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "gitlab": {
      "options": {
        "instanceUrl": "https://gitlab.com"
      }
    }
  }
}
```

##### Herramientas de API de GitLab (opcionales, pero muy recomendables)

Para acceder a herramientas GitLab (solicitudes de fusión, problemas, canalizaciones, CI/CD, etc.):

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

Este complemento proporciona capacidades integrales de administración del repositorio GitLab que incluyen revisiones de MR, seguimiento de problemas, monitoreo de canalizaciones y más.

---

### GitHub Copilot

Para utilizar su suscripción GitHub Copilot con opencode:

:::note
Algunos modelos pueden necesitar un [Pro+
suscripción](https://github.com/features/copilot/plans) para usar.
:::

1. Ejecute el comando `/connect` y busque GitHub Copilot.

   ```txt
   /connect
   ```

2. Navegue hasta [github.com/login/device](https://github.com/login/device) e ingrese el código.

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

3. Ahora ejecute el comando `/models` para seleccionar el modelo que desea.

   ```txt
   /models
   ```

---

### Google Vertex AI

Para utilizar Google Vertex AI con OpenCode:

1. Dirígete a **Model Garden** en Google Cloud Console y verifica el
   Modelos disponibles en su región.

   :::note
   Debes tener un proyecto de Google Cloud con Vertex AI API habilitado.
   :::

2. Establezca las variables de entorno requeridas:
   - `GOOGLE_CLOUD_PROJECT`: tu ID de proyecto de Google Cloud
   - `VERTEX_LOCATION` (opcional): la región para Vertex AI (por defecto es `global`)
   - Autenticación (elija una):
     - `GOOGLE_APPLICATION_CREDENTIALS`: ruta al archivo clave JSON de su cuenta de servicio
     - Autenticar usando gcloud CLI: `gcloud auth application-default login`

   Configúrelos mientras ejecuta opencode.

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

   O agréguelos a su perfil de bash.

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

:::tip
La región `global` mejora la disponibilidad y reduce los errores sin costo adicional. Utilice puntos finales regionales (por ejemplo, `us-central1`) para los requisitos de residencia de datos. [Más información](https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/use-partner-models#regional_and_global_endpoints)
:::

3. Ejecute el comando `/models` para seleccionar el modelo que desee.

   ```txt
   /models
   ```

---

### Groq

1. Dirígete a la [consola Groq](https://console.groq.com/), haz clic en **Crear clave API** y copia la clave.

2. Ejecute el comando `/connect` y busque Groq.

   ```txt
   /connect
   ```

3. Ingrese la clave API para el proveedor.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar el que desee.

   ```txt
   /models
   ```

---

### Hugging Face

[Hugging Face Inference Providers](https://huggingface.co/docs/inference-providers) proporciona acceso a modelos abiertos compatibles con más de 17 proveedores.

1. Ve a [Hugging Face settings](https://huggingface.co/settings/tokens/new?ownUserPermissions=inference.serverless.write&tokenType=fineGrained) para crear un token con permisos para llamar a inference providers.

2. Ejecute el comando `/connect` y busque **Hugging Face**.

   ```txt
   /connect
   ```

3. Ingresa tu token de Hugging Face.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo como _Kimi-K2-Instruct_ o _GLM-4.6_.

   ```txt
   /models
   ```

---

### Helicone

[Helicone](https://helicone.ai) es una plataforma de observabilidad LLM que proporciona registro, monitoreo y análisis para sus aplicaciones de IA. Helicone AI Gateway enruta sus solicitudes al proveedor apropiado automáticamente según el modelo.

1. Dirígete a [Helicone](https://helicone.ai), crea una cuenta y genera una clave API desde tu panel.

2. Ejecute el comando `/connect` y busque **Helicone**.

   ```txt
   /connect
   ```

3. Ingrese su clave Helicone API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo.

   ```txt
   /models
   ```

Para obtener más proveedores y funciones avanzadas como almacenamiento en caché y limitación de velocidad, consulte la [documentación de Helicone](https://docs.helicone.ai).

#### Configuraciones opcionales

En caso de que vea una característica o modelo de Helicone que no esté configurado automáticamente a través de opencode, siempre podrá configurarlo usted mismo.

Aquí está el [Directorio de modelos de Helicone](https://helicone.ai/models), lo necesitará para obtener las ID de los modelos que desea agregar.

```jsonc title="~/.config/opencode/opencode.jsonc"
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "helicone": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Helicone",
      "options": {
        "baseURL": "https://ai-gateway.helicone.ai",
      },
      "models": {
        "gpt-4o": {
          // Model ID (from Helicone's model directory page)
          "name": "GPT-4o", // Your own custom name for the model
        },
        "claude-sonnet-4-20250514": {
          "name": "Claude Sonnet 4",
        },
      },
    },
  },
}
```

#### Encabezados personalizados

Helicone admite encabezados personalizados para funciones como almacenamiento en caché, seguimiento de usuarios y gestión de sesiones. Agréguelos a la configuración de su proveedor usando `options.headers`:

```jsonc title="~/.config/opencode/opencode.jsonc"
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "helicone": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Helicone",
      "options": {
        "baseURL": "https://ai-gateway.helicone.ai",
        "headers": {
          "Helicone-Cache-Enabled": "true",
          "Helicone-User-Id": "opencode",
        },
      },
    },
  },
}
```

##### Seguimiento de sesión

La función [Sesiones](https://docs.helicone.ai/features/sessions) de Helicone le permite agrupar solicitudes LLM relacionadas. Utilice el complemento [opencode-helicone-session](https://github.com/H2Shami/opencode-helicone-session) para registrar automáticamente cada conversación OpenCode como una sesión en Helicone.

```bash
npm install -g opencode-helicone-session
```

Agréguelo a su configuración.

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

El complemento inyecta encabezados `Helicone-Session-Id` y `Helicone-Session-Name` en sus solicitudes. En la página Sesiones de Helicone, verá cada conversación OpenCode enumerada como una sesión separada.

##### Cabeceras comunes de Helicone

| Encabezado                 | Descripción                                                                       |
| -------------------------- | --------------------------------------------------------------------------------- |
| `Helicone-Cache-Enabled`   | Habilitar el almacenamiento en caché de respuestas (`true`/`false`)               |
| `Helicone-User-Id`         | Seguimiento de métricas por usuario                                               |
| `Helicone-Property-[Name]` | Agregar propiedades personalizadas (por ejemplo, `Helicone-Property-Environment`) |
| `Helicone-Prompt-Id`       | Solicitudes asociadas con versiones rápidas                                       |

Consulte el [Directorio de encabezados de Helicone](https://docs.helicone.ai/helicone-headers/header-directory) para conocer todos los encabezados disponibles.

---

### llama.cpp

Puede configurar opencode para usar modelos locales a través de la utilidad llama-server de [llama.cpp](https://github.com/ggml-org/llama.cpp)

```json title="opencode.json" "llama.cpp" {5, 6, 8, 10-15}
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llama.cpp": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "llama-server (local)",
      "options": {
        "baseURL": "http://127.0.0.1:8080/v1"
      },
      "models": {
        "qwen3-coder:a3b": {
          "name": "Qwen3-Coder: a3b-30b (local)",
          "limit": {
            "context": 128000,
            "output": 65536
          }
        }
      }
    }
  }
}
```

En este ejemplo:

- `llama.cpp` es el ID del proveedor personalizado. Puede ser cualquier cadena que desees.
- `npm` especifica el paquete que se utilizará para este proveedor. Aquí, `@ai-sdk/openai-compatible` se utiliza para cualquier OpenAI compatible con API.
- `name` es el nombre para mostrar del proveedor en la interfaz de usuario.
- `options.baseURL` es el punto final del servidor local.
- `models` es un mapa de ID de modelo para 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 IO.NET](https://ai.io.net/), crea una cuenta y genera una clave API.

2. Ejecute el comando `/connect` y busque **IO.NET**.

   ```txt
   /connect
   ```

3. Ingrese su clave IO.NET API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo.

   ```txt
   /models
   ```

---

### LM Studio

Puede configurar opencode para usar modelos locales a través de LM Studio.

```json title="opencode.json" "lmstudio" {5, 6, 8, 10-14}
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "lmstudio": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "LM Studio (local)",
      "options": {
        "baseURL": "http://127.0.0.1:1234/v1"
      },
      "models": {
        "google/gemma-3n-e4b": {
          "name": "Gemma 3n-e4b (local)"
        }
      }
    }
  }
}
```

En este ejemplo:

- `lmstudio` es el ID del proveedor personalizado. Puede ser cualquier cadena que desees.
- `npm` especifica el paquete que se utilizará para este proveedor. Aquí, `@ai-sdk/openai-compatible` se utiliza para cualquier OpenAI compatible con API.
- `name` es el nombre para mostrar del proveedor en la interfaz de usuario.
- `options.baseURL` es el punto final del servidor local.
- `models` es un mapa de ID de modelo para 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 Moonshot AI](https://platform.moonshot.ai/console), crea una cuenta y haz clic en **Crear clave API**.

2. Ejecute el comando `/connect` y busque **Moonshot AI**.

   ```txt
   /connect
   ```

3. Ingrese su clave Moonshot API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar _Kimi K2_.

   ```txt
   /models
   ```

---

### MiniMax

1. Dirígete a la [Consola MiniMax API](https://platform.minimax.io/login), crea una cuenta y genera una clave API.

2. Ejecute el comando `/connect` y busque **MiniMax**.

   ```txt
   /connect
   ```

3. Ingrese su clave MiniMax API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo como _M2.1_.

   ```txt
   /models
   ```

---

### Nebius Token Factory

1. Dirígete a la [consola de Nebius Token Factory](https://tokenfactory.nebius.com/), crea una cuenta y haz clic en **Agregar clave**.

2. Ejecute el comando `/connect` y busque **Nebius Token Factory**.

   ```txt
   /connect
   ```

3. Ingrese su clave API de Nebius Token Factory.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo como _Kimi K2 Instruct_.

   ```txt
   /models
   ```

---

### Ollama

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

:::tip
Ollama puede configurarse automáticamente para OpenCode. Consulte los [documentos de integración de Ollama](https://docs.ollama.com/integrations/opencode) para obtener más detalles.
:::

```json title="opencode.json" "ollama" {5, 6, 8, 10-14}
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama (local)",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "llama2": {
          "name": "Llama 2"
        }
      }
    }
  }
}
```

En este ejemplo:

- `ollama` es el ID del proveedor personalizado. Puede ser cualquier cadena que desees.
- `npm` especifica el paquete que se utilizará para este proveedor. Aquí, `@ai-sdk/openai-compatible` se utiliza para cualquier OpenAI compatible con API.
- `name` es el nombre para mostrar del proveedor en la interfaz de usuario.
- `options.baseURL` es el punto final del servidor local.
- `models` es un mapa de ID de modelo para sus configuraciones. El nombre del modelo se mostrará en la lista de selección de modelos.

:::tip
Si las llamadas a herramientas no funcionan, intente aumentar `num_ctx` en Ollama. Comience alrededor de 16k - 32k.
:::

---

### Ollama Cloud

Para usar Ollama Cloud con OpenCode:

1. Dirígete a [https://ollama.com/](https://ollama.com/) e inicia sesión o crea una cuenta.

2. Vaya a **Configuración** > **Claves** y haga clic en **Agregar clave API** para generar una nueva clave API.

3. Copie la clave API para usarla en OpenCode.

4. Ejecute el comando `/connect` y busque **Ollama Cloud**.

   ```txt
   /connect
   ```

5. Ingrese su clave Ollama Cloud API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

6. **Importante**: Antes de usar modelos en la nube en OpenCode, debe obtener la información del modelo localmente:

   ```bash
   ollama pull gpt-oss:20b-cloud
   ```

7. Ejecute el comando `/models` para seleccionar su modelo de Ollama Cloud.

   ```txt
   /models
   ```

---

### OpenAI

Recomendamos registrarse en [ChatGPT Plus o Pro](https://chatgpt.com/pricing).

1. Una vez que se haya registrado, ejecute el comando `/connect` y seleccione OpenAI.

   ```txt
   /connect
   ```

2. Aquí puedes seleccionar la opción **ChatGPT Plus/Pro** y se abrirá tu navegador.
   y pedirle que se autentique.

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

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

   ```txt
   /models
   ```

##### Usando las teclas API

Si ya tiene una clave API, puede seleccionar **Ingresar manualmente la clave API** y pegarla en su terminal.

---

### OpenCode Zen

OpenCode Zen es una lista de modelos probados y verificados proporcionada por el equipo OpenCode. [Más información](/docs/zen).

1. Inicie sesión en **<a href={console}>OpenCode Zen</a>** y haga clic en **Crear API clave**.

2. Ejecute el comando `/connect` y busque **OpenCode Zen**.

   ```txt
   /connect
   ```

3. Ingrese su clave OpenCode API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo como _Qwen 3 Coder 480B_.

   ```txt
   /models
   ```

---

### OpenRouter

1. Dirígete al [panel de OpenRouter](https://openrouter.ai/settings/keys), haz clic en **Crear clave API** y copia la clave.

2. Ejecute el comando `/connect` y busque OpenRouter.

   ```txt
   /connect
   ```

3. Ingrese la clave API para el proveedor.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Muchos modelos de OpenRouter están precargados de forma predeterminada, ejecute el comando `/models` para seleccionar el que desee.

   ```txt
   /models
   ```

   También puede agregar modelos adicionales a través de su configuración opencode.

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

5. También puedes personalizarlos a través de tu configuración opencode. A continuación se muestra un ejemplo de cómo especificar un proveedor.

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

---

### SAP AI Core

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

1. Vaya a su [SAP BTP Cockpit](https://account.hana.ondemand.com/), navegue hasta su instancia de servicio SAP AI Core y cree una clave de servicio.

   :::consejo
   La clave de servicio es un objeto JSON que contiene `clientid`, `clientsecret`, `url` y `serviceurls.AI_API_URL`. Puede encontrar su instancia de AI Core en **Servicios** > **Instancias y suscripciones** en BTP Cockpit.
   :::

2. Ejecute el comando `/connect` y busque **SAP AI Core**.

   ```txt
   /connect
   ```

3. Ingrese su clave de servicio JSON.

   ```txt
   ┌ Service key
   │
   │
   └ enter
   ```

   O configure la variable de entorno `AICORE_SERVICE_KEY`:

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

   O agrégalo a tu perfil de bash:

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

4. Opcionalmente, configure el ID de implementación y el grupo de recursos:

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

   :::note
   Estas configuraciones son opcionales y deben configurarse de acuerdo con su configuración de SAP AI Core.
   :::

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

   ```txt
   /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 en infraestructura europea.

1. Diríjase al [Portal STACKIT](https://portal.stackit.cloud), navegue hasta **AI Model Serving** y cree un token de autenticación para su proyecto.

   :::tip
   Necesita una cuenta de cliente STACKIT, una cuenta de usuario y un proyecto antes de crear tokens de autenticación.
   :::

2. Ejecute el comando `/connect` y busque **STACKIT**.

   ```txt
   /connect
   ```

3. Ingrese su token de autenticación de STACKIT AI Model Serving.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar entre los modelos disponibles como _Qwen3-VL 235B_ o _Llama 3.3 70B_.

   ```txt
   /models
   ```

---

### OVHcloud AI Endpoints

1. Dirígete al [panel de OVHcloud](https://ovh.com/manager). Navegue a la sección `Public Cloud`, `AI & Machine Learning` > `AI Endpoints` y en la pestaña `API Keys`, haga clic en **Crear una nueva clave API**.

2. Ejecute el comando `/connect` y busque **OVHcloud AI Endpoints**.

   ```txt
   /connect
   ```

3. Introduzca la clave API de sus OVHcloud AI Endpoints.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo como _gpt-oss-120b_.

   ```txt
   /models
   ```

---

### Scaleway

Para utilizar [API generativas de Scaleway](https://www.scaleway.com/en/docs/generative-apis/) con OpenCode:

1. Dirígete a la [Configuración de IAM de la consola Scaleway](https://console.scaleway.com/iam/api-keys) para generar una nueva clave API.

2. Ejecute el comando `/connect` y busque **Scaleway**.

   ```txt
   /connect
   ```

3. Ingrese su clave Scaleway API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo como _devstral-2-123b-instruct-2512_ o _gpt-oss-120b_.

   ```txt
   /models
   ```

---

### Together AI

1. Dirígete a la [consola de Together AI](https://api.together.ai), crea una cuenta y haz clic en **Agregar clave**.

2. Ejecute el comando `/connect` y busque **Together AI**.

   ```txt
   /connect
   ```

3. Ingrese su clave Together AI API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo como _Kimi K2 Instruct_.

   ```txt
   /models
   ```

---

### Venice AI

1. Dirígete a la [consola de Venice AI](https://venice.ai), crea una cuenta y genera una clave API.

2. Ejecute el comando `/connect` y busque **Venice AI**.

   ```txt
   /connect
   ```

3. Ingrese su clave Venice AI API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo como _Llama 3.3 70B_.

   ```txt
   /models
   ```

---

### Vercel AI Gateway

Vercel AI Gateway le permite acceder a modelos de OpenAI, Anthropic, Google, xAI y más a través de un punto final unificado. Los modelos se ofrecen a precio de lista sin margen de beneficio.

1. Dirígete al [panel de Vercel](https://vercel.com/), navega hasta la pestaña **AI Gateway** y haz clic en **API claves** para crear una nueva clave API.

2. Ejecute el comando `/connect` y busque **Vercel AI Gateway**.

   ```txt
   /connect
   ```

3. Ingrese su clave Vercel AI Gateway API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo.

   ```txt
   /models
   ```

También puede personalizar modelos a través de su configuración opencode. A continuación se muestra un ejemplo de cómo especificar el orden de enrutamiento del proveedor.

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

Algunas opciones de enrutamiento útiles:

| Opción              | Descripción                                                             |
| ------------------- | ----------------------------------------------------------------------- |
| `order`             | Secuencia de proveedores para probar                                    |
| `only`              | Restringir a proveedores específicos                                    |
| `zeroDataRetention` | Utilice únicamente proveedores con políticas de retención de datos cero |

---

### xAI

1. Dirígete a la [consola xAI](https://console.x.ai/), crea una cuenta y genera una clave API.

2. Ejecute el comando `/connect` y busque **xAI**.

   ```txt
   /connect
   ```

3. Ingrese su clave xAI API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo como _Grok Beta_.

   ```txt
   /models
   ```

---

### Z.AI

1. Dirígete a la [consola Z.AI API](https://z.ai/manage-apikey/apikey-list), crea una cuenta y haz clic en **Crear una nueva clave API**.

2. Ejecute el comando `/connect` y busque **Z.AI**.

   ```txt
   /connect
   ```

   Si está suscrito al **Plan de codificación GLM**, seleccione **Plan de codificación Z.AI**.

3. Ingrese su clave Z.AI API.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Ejecute el comando `/models` para seleccionar un modelo como _GLM-4.7_.

   ```txt
   /models
   ```

---

### ZenMux

1. Dirígete al [panel de ZenMux](https://zenmux.ai/settings/keys), haz clic en **Crear clave API** y copia la clave.

2. Ejecute el comando `/connect` y busque ZenMux.

   ```txt
   /connect
   ```

3. Ingrese la clave API para el proveedor.

   ```txt
   ┌ API key
   │
   │
   └ enter
   ```

4. Muchos modelos de ZenMux están precargados de forma predeterminada, ejecute el comando `/models` para seleccionar el que desee.

   ```txt
   /models
   ```

   También puede agregar modelos adicionales a través de su configuración opencode.

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

---

## Proveedor personalizado

Para agregar cualquier proveedor **compatible con OpenAI** que no aparezca en el comando `/connect`:

:::tip
Puede utilizar cualquier proveedor compatible con OpenAI con opencode. La mayoría de los proveedores de IA modernos ofrecen API compatibles con OpenAI.
:::

1. Ejecute el comando `/connect` y desplácese hacia abajo hasta **Otro**.

   ```bash
   $ /connect

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

2. Ingrese una identificación única para el proveedor.

   ```bash
   $ /connect

   ┌  Add credential
   │
   ◇  Enter provider id
   │  myprovider
   └
   ```

   :::note
   Elija una identificación memorable, la usará en su archivo de configuración.
   :::

3. Ingrese su clave API para el proveedor.

   ```bash
   $ /connect

   ┌  Add credential
   │
   ▲  This only stores a credential for myprovider - you will need to configure it in opencode.json, check the docs for examples.
   │
   ◇  Enter your API key
   │  sk-...
   └
   ```

4. Cree o actualice su archivo `opencode.json` en el directorio de su proyecto:

   ```json title="opencode.json" ""myprovider"" {5-15}
   {
     "$schema": "https://opencode.ai/config.json",
     "provider": {
       "myprovider": {
         "npm": "@ai-sdk/openai-compatible",
         "name": "My AI ProviderDisplay Name",
         "options": {
           "baseURL": "https://api.myprovider.com/v1"
         },
         "models": {
           "my-model-name": {
             "name": "My Model Display Name"
           }
         }
       }
     }
   }
   ```

   Aquí están las opciones de configuración:
   - **npm**: paquete AI SDK para usar, `@ai-sdk/openai-compatible` para proveedores compatibles con OpenAI
   - **nombre**: nombre para mostrar en la interfaz de usuario.
   - **modelos**: Modelos disponibles.
   - **options.baseURL**: API URL del punto final.
   - **options.apiKey**: Opcionalmente, configure la clave API, si no usa autenticación.
   - **options.headers**: Opcionalmente, configure encabezados personalizados.

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

5. Ejecute el comando `/models` y su proveedor y modelos personalizados aparecerán en la lista de selección.

---

##### Ejemplo

A continuación se muestra un ejemplo de configuración de las opciones `apiKey`, `headers` y modelo `limit`.

```json title="opencode.json" {9,11,17-20}
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "myprovider": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "My AI ProviderDisplay Name",
      "options": {
        "baseURL": "https://api.myprovider.com/v1",
        "apiKey": "{env:ANTHROPIC_API_KEY}",
        "headers": {
          "Authorization": "Bearer custom-token"
        }
      },
      "models": {
        "my-model-name": {
          "name": "My Model Display Name",
          "limit": {
            "context": 200000,
            "output": 65536
          }
        }
      }
    }
  }
}
```

Detalles de configuración:

- **apiKey**: se configura usando la sintaxis de la variable `env`, [más información](/docs/config#env-vars).
- **encabezados**: encabezados personalizados enviados con cada solicitud.
- **limit.context**: tokens de entrada máximos que acepta el modelo.
- **limit.output**: tokens máximos que el modelo puede generar.

Los campos `limit` le permiten a OpenCode comprender cuánto contexto le queda. Los proveedores estándar los extraen de models.dev automáticamente.

---

## Solución de problemas

Si tiene problemas para configurar un proveedor, verifique lo siguiente:

1. **Verifique la configuración de autenticación**: Ejecute `opencode auth list` para ver si las credenciales
   para el proveedor se agregan a su configuración.

   Esto no se aplica a proveedores como Amazon Bedrock, que dependen de variables de entorno para su autenticación.

2. Para proveedores personalizados, verifique la configuración opencode y:
   - Asegúrese de que el ID del proveedor utilizado en el comando `/connect` coincida con el ID en su configuración opencode.
   - Se utiliza el paquete npm correcto para el proveedor. Por ejemplo, utilice `@ai-sdk/cerebras` para Cerebras. Y para todos los demás proveedores compatibles con OpenAI, utilice `@ai-sdk/openai-compatible`.
   - Verifique que se utilice el punto final API correcto en el campo `options.baseURL`.