Buckets:

GHHG10
/

CodeServer

Files

xet

GHHG10/CodeServer / opencode /packages /web /src /content /docs /es /providers.mdx

GHHG10

about 2 months ago

download

raw

49.8 kB

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

	---

	### FrogBot

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

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

	```txt
	/connect
	```

	3. Ingrese su clave de frogbot 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`.

Xet Storage Details

Size:: 49.8 kB
Xet hash:: a01484a7a05a6cd1d34092c43fa6d39b710ab6ef4500a357183c558a181b0d68

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.