Proveedores

Uso de cualquier proveedor de LLM en OpenCode.

OpenCode utiliza el AI SDK y Models.dev para admitir ms de 75 proveedores de LLM y admite la ejecucin de modelos locales.

Para agregar un proveedor, necesita:

Agregar las claves API del proveedor usando el comando /connect.
Configurar el proveedor en su configuracin de OpenCode.

Credenciales

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

Configuracin

Puede personalizar los proveedores a travs de la seccin provider en su configuracin de OpenCode.

URL base

Puede personalizar la URL base para cualquier proveedor estableciendo la opcin baseURL. Esto es til al usar servicios proxy o puntos finales personalizados.

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

OpenCode Zen

OpenCode Zen es una lista de modelos proporcionados por el equipo de OpenCode que han sido probados y verificados para funcionar bien con OpenCode. Ms informacin.

Ejecute el comando /connect en el TUI, seleccione opencode y vaya a opencode.ai/auth.
```
/connect
```
Inicie sesin, agregue sus datos de facturacin y copie su clave API.
Pegue su clave API.
```
┌ API key
│
│
└ enter
```
Ejecute /models en el TUI para ver la lista de modelos que recomendamos.
```
/models
```

Funciona como cualquier otro proveedor en OpenCode. 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 una PR.

Amazon Bedrock

Para usar Amazon Bedrock con OpenCode:

Vaya al Catlogo de modelos en la consola de Amazon Bedrock y solicite acceso a los modelos que desea.

Debe tener acceso al modelo que desea en Amazon Bedrock.
Configurar la autenticacin usando uno de los siguientes mtodos:

Variables de entorno (Inicio rpido)

Establezca una de estas variables de entorno mientras ejecuta opencode:
Ventana de terminal
```
# Opcin 1: Usar claves de acceso de AWS
AWS_ACCESS_KEY_ID=XXX AWS_SECRET_ACCESS_KEY=YYY opencode

# Opcin 2: Usar perfil de AWS con nombre
AWS_PROFILE=my-profile opencode

# Opcin 3: Usar token de portador de Bedrock
AWS_BEARER_TOKEN_BEDROCK=XXX opencode
```
O agrgelas a su perfil de bash:
~/.bash_profile
```
export AWS_PROFILE=my-dev-profile
export AWS_REGION=us-east-1
```
Archivo de configuracin (Recomendado)

Para configuracin especfica del proyecto o persistente, use opencode.json:
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "amazon-bedrock": {
      "options": {
        "region": "us-east-1",
        "profile": "my-aws-profile"
      }
    }
  }
}
```
Opciones disponibles:
- region - Regin de AWS (por ejemplo, us-east-1, eu-west-1)
- profile - Perfil con nombre de AWS desde ~/.aws/credentials
- endpoint - URL de punto final personalizado para puntos finales de VPC (alias para la opcin genrica baseURL)
Las opciones del archivo de configuracin tienen prioridad sobre las variables de entorno.

Avanzado: Puntos finales de VPC

Si est usando puntos finales de VPC para Bedrock:
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "amazon-bedrock": {
      "options": {
        "region": "us-east-1",
        "profile": "production",
        "endpoint": "https://bedrock-runtime.us-east-1.vpce-xxxxx.amazonaws.com"
      }
    }
  }
}
```
La opcin endpoint es un alias para la opcin genrica baseURL, usando terminologa especfica de AWS. Si se especifican tanto endpoint como baseURL, endpoint tiene prioridad.

Mtodos de autenticacin
- AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY: Cree un usuario de IAM y genere claves de acceso en la consola de AWS
- AWS_PROFILE: Use perfiles con nombre desde ~/.aws/credentials. Primero configure con aws configure --profile my-profile o aws sso login
- AWS_BEARER_TOKEN_BEDROCK: Genere claves API a largo plazo desde la consola de Amazon Bedrock
Prioridad de autenticacin

Amazon Bedrock usa la siguiente prioridad de autenticacin:
1. Token de portador - Variable de entorno AWS_BEARER_TOKEN_BEDROCK o token del comando /connect
2. Cadena de credenciales de AWS - Perfil, claves de acceso, credenciales compartidas, roles de IAM, metadatos de instancia
Cuando se establece un token de portador (va /connect o AWS_BEARER_TOKEN_BEDROCK), tiene prioridad sobre todos los mtodos de credenciales de AWS, incluidos los perfiles configurados.
Ejecute el comando /models para seleccionar el modelo que desea.
```
/models
```

Anthropic

Recomendamos suscribirse a Claude Pro o Max.

Una vez que se haya suscrito, ejecute el comando /connect y seleccione Anthropic.
```
/connect
```
Aqu puede seleccionar la opcin Claude Pro/Max y esto abrir su navegador y le pedir que se autentique.
```
┌ Select auth method
│
│ Claude Pro/Max
│ Create an API Key
│ Manually enter API Key
└
```
Ahora todos los modelos de Anthropic deberan estar disponibles cuando use el comando /models.
```
/models
```

También puede seleccionar Crear una clave API si no tiene una suscripcin Pro/Max. Esto tambin abrir su navegador y le pedir que inicie sesin en Anthropic y le dar un cdigo que puede pegar en su terminal.

O si ya tiene una clave API, puede seleccionar Ingresar clave API manualmente y pegarla en su terminal.

Azure OpenAI

Vaya al portal de Azure y cree un recurso Azure OpenAI. Necesitar:
- Nombre del recurso: Esto se convierte en parte de su punto final API (https://RESOURCE_NAME.openai.azure.com/)
- Clave API: Ya sea KEY 1 o KEY 2 de su recurso
Vaya a Azure AI Foundry e implemente un modelo.

El nombre de implementacin debe coincidir con el nombre del modelo para que opencode funcione correctamente.
Ejecute el comando /connect y busque Azure.
```
/connect
```
Ingrese su clave API.
```
┌ API key
│
│
└ enter
```
Establezca su nombre de recurso como variable de entorno:
Ventana de terminal
```
AZURE_RESOURCE_NAME=XXX opencode
```
O agrguelo a su perfil de bash:
~/.bash_profile
```
export AZURE_RESOURCE_NAME=XXX
```
Ejecute el comando /models para seleccionar su modelo implementado.
```
/models
```

Azure Cognitive Services

Vaya al portal de Azure y cree un recurso Azure OpenAI. Necesitar:
- Nombre del recurso: Esto se convierte en parte de su punto final API (https://AZURE_COGNITIVE_SERVICES_RESOURCE_NAME.cognitiveservices.azure.com/)
- Clave API: Ya sea KEY 1 o KEY 2 de su recurso
Vaya a Azure AI Foundry e implemente un modelo.

El nombre de implementacin debe coincidir con el nombre del modelo para que opencode funcione correctamente.
Ejecute el comando /connect y busque Azure Cognitive Services.
```
/connect
```
Ingrese su clave API.
```
┌ API key
│
│
└ enter
```
Establezca su nombre de recurso como variable de entorno:
Ventana de terminal
```
AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
```
O agrguelo a su perfil de bash:
~/.bash_profile
```
export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX
```
Ejecute el comando /models para seleccionar su modelo implementado.
```
/models
```

Baseten

Vaya a Baseten, cree una cuenta y genere una clave API.
Ejecute el comando /connect y busque Baseten.
```
/connect
```
Ingrese su clave API de Baseten.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo.
```
/models
```

Cerebras

Vaya a la consola de Cerebras, cree una cuenta y genere una clave API.
Ejecute el comando /connect y busque Cerebras.
```
/connect
```
Ingrese su clave API de Cerebras.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo como Qwen 3 Coder 480B.
```
/models
```

Cloudflare AI Gateway

Cloudflare AI Gateway le permite acceder a modelos de OpenAI, Anthropic, Workers AI y ms a travs de un punto final unificado. Con Facturacin unificada no necesita claves API separadas para cada proveedor.

Vaya al panel de Cloudflare, navegue a AI > AI Gateway y cree una nueva puerta de enlace.

Establezca su ID de cuenta e ID de puerta de enlace como variables de entorno.

export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
export CLOUDFLARE_GATEWAY_ID=your-gateway-id

Ejecute el comando /connect y busque Cloudflare AI Gateway.
```
/connect
```
Ingrese su token API de Cloudflare.
```
┌ API key
│
│
└ enter
```
O establzalo como variable de entorno.
~/.bash_profile
```
export CLOUDFLARE_API_TOKEN=your-api-token
```

Ejecute el comando /models para seleccionar un modelo.

/models

También puede agregar modelos a travs de su configuracin de opencode.

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

Cortecs

Vaya a la consola de Cortecs, cree una cuenta y genere una clave API.
Ejecute el comando /connect y busque Cortecs.
```
/connect
```
Ingrese su clave API de Cortecs.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo como Kimi K2 Instruct.
```
/models
```

DeepSeek

Vaya a la consola de DeepSeek, cree una cuenta y haga clic en Crear nueva clave API.
Ejecute el comando /connect y busque DeepSeek.
```
/connect
```
Ingrese su clave API de DeepSeek.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo DeepSeek como DeepSeek Reasoner.
```
/models
```

Deep Infra

Vaya al panel de Deep Infra, cree una cuenta y genere una clave API.
Ejecute el comando /connect y busque Deep Infra.
```
/connect
```
Ingrese su clave API de Deep Infra.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo.
```
/models
```

Fireworks AI

Vaya a la consola de Fireworks AI, cree una cuenta y haga clic en Crear clave API.
Ejecute el comando /connect y busque Fireworks AI.
```
/connect
```
Ingrese su clave API de Fireworks AI.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo como Kimi K2 Instruct.
```
/models
```

GitHub Copilot

Para usar su suscripcin de GitHub Copilot con opencode:

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

Vaya a github.com/login/device e ingrese el cdigo.

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

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

Google Vertex AI

Para usar Google Vertex AI con OpenCode:

Vaya al Model Garden en la consola de Google Cloud y verifique los modelos disponibles en su regin.

Debe tener un proyecto de Google Cloud con la API de Vertex AI habilitada.
Establezca las variables de entorno requeridas:
- GOOGLE_CLOUD_PROJECT: Su ID de proyecto de Google Cloud
- VERTEX_LOCATION (opcional): La regin para Vertex AI (por defecto es global)
- Autenticacin (elija una):
  - GOOGLE_APPLICATION_CREDENTIALS: Ruta a su archivo de clave JSON de cuenta de servicio
  - Autentquese usando gcloud CLI: gcloud auth application-default login
Establzcalas mientras ejecuta opencode.
Ventana de terminal
```
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id opencode
```
O agrgalas a su perfil de bash.
~/.bash_profile
```
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
export GOOGLE_CLOUD_PROJECT=your-project-id
export VERTEX_LOCATION=global
```

Ejecute el comando /models para seleccionar el modelo que desea.
```
/models
```

Groq

Vaya a la consola de Groq, haga clic en Crear clave API y copie la clave.
Ejecute el comando /connect y busque Groq.
```
/connect
```
Ingrese la clave API del proveedor.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar el que desea.
```
/models
```

Hugging Face

Hugging Face Inference Providers proporciona acceso a modelos de cdigo abierto compatibles con ms de 17 proveedores.

Vaya a la configuracin de Hugging Face para crear un token con permiso para realizar llamadas a proveedores de inferencia.
Ejecute el comando /connect y busque Hugging Face.
```
/connect
```
Ingrese su token de Hugging Face.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo como Kimi-K2-Instruct o GLM-4.6.
```
/models
```

Helicone

Helicone es una plataforma de observabilidad de LLM que proporciona registro, monitoreo y analticas para sus aplicaciones de IA. La puerta de enlace de IA de Helicone enruta sus solicitudes al proveedor apropiado automticamente segn el modelo.

Vaya a Helicone, cree una cuenta y genere una clave API desde su panel.
Ejecute el comando /connect y busque Helicone.
```
/connect
```
Ingrese su clave API de Helicone.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo.
```
/models
```

Para ms proveedores y funciones avanzadas como almacenamiento en cach y limitacin de velocidad, consulte la documentacin de Helicone.

Configuraciones opcionales

En caso de que vea una funcin o modelo de Helicone que no est configurado automticamente a travs de opencode, siempre puede configurarlo usted mismo.

Aqu est est el Directorio de modelos de Helicone, lo necesitar para obtener los ID de los modelos que desea agregar.

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "helicone": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Helicone",
      "options": {
        "baseURL": "https://ai-gateway.helicone.ai",
      },
      "models": {
        "gpt-4o": {
          // ID de modelo (de la pgina del directorio de modelos de Helicone)
          "name": "GPT-4o", // Su propio nombre personalizado para el modelo
        },
        "claude-sonnet-4-20250514": {
          "name": "Claude Sonnet 4",
        },
      },
    },
  },
}

Encabezados personalizados

Helicone admite encabezados personalizados para funciones como almacenamiento en cach, seguimiento de usuarios y gestin de sesiones. Agrgelos a su configuracin de proveedor usando options.headers:

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

Seguimiento de sesiones

La funcin Sesiones de Helicone le permite agrupar solicitudes de LLM relacionadas. Use el complemento opencode-helicone-session para registrar automticamente cada conversacin de OpenCode como una sesin en Helicone.

npm install -g opencode-helicone-session

Agrgalo a tu configuracin.

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

El complemento inyecta los encabezados Helicone-Session-Id y Helicone-Session-Name en sus solicitudes. En la pgina de Sesiones de Helicone, ver cada conversacin de OpenCode listada como una sesin separada.

Encabezados comunes de Helicone

Encabezado	Descripcin
`Helicone-Cache-Enabled`	Habilitar almacenamiento en cach de respuestas (`true`/`false`)
`Helicone-User-Id`	Rastrear mtricas por usuario
`Helicone-Property-[Name]`	Agregar propiedades personalizadas (por ejemplo, `Helicone-Property-Environment`)
`Helicone-Prompt-Id`	Asociar solicitudes con versiones de prompt

Vea el Directorio de encabezados de Helicone para todos los encabezados disponibles.

llama.cpp

Puede configurar opencode para usar modelos locales a travs de la utilidad llama-server de llama.cpp

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

En este ejemplo:

llama.cpp es el ID de proveedor personalizado. Puede ser cualquier cadena que desee.
npm especifica el paquete a usar para este proveedor. Aqu, @ai-sdk/openai-compatible se usa para cualquier API compatible con OpenAI.
name es el nombre para mostrar del proveedor en la interfaz de usuario.
options.baseURL es el punto final para el servidor local.
models es un mapa de ID de modelo a sus configuraciones. El nombre del modelo se mostrar en la lista de seleccin de modelos.

IO.NET

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

Vaya a la consola de IO.NET, cree una cuenta y genere una clave API.
Ejecute el comando /connect y busque IO.NET.
```
/connect
```
Ingrese su clave API de IO.NET.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo.
```
/models
```

LM Studio

Puede configurar opencode para usar modelos locales a travs de LM Studio.

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

En este ejemplo:

lmstudio es el ID de proveedor personalizado. Puede ser cualquier cadena que desee.
npm especifica el paquete a usar para este proveedor. Aqu, @ai-sdk/openai-compatible se usa para cualquier API compatible con OpenAI.
name es el nombre para mostrar del proveedor en la interfaz de usuario.
options.baseURL es el punto final para el servidor local.
models es un mapa de ID de modelo a sus configuraciones. El nombre del modelo se mostrar en la lista de seleccin de modelos.

Moonshot AI

Para usar Kimi K2 de Moonshot AI:

Vaya a la consola de Moonshot AI, cree una cuenta y haga clic en Crear clave API.
Ejecute el comando /connect y busque Moonshot AI.
```
/connect
```
Ingrese su clave API de Moonshot.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar Kimi K2.
```
/models
```

MiniMax

Vaya a la Consola API de MiniMax, cree una cuenta y genere una clave API.
Ejecute el comando /connect y busque MiniMax.
```
/connect
```
Ingrese su clave API de MiniMax.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo como M2.1.
```
/models
```

Nebius Token Factory

Vaya a la consola de Nebius Token Factory, cree una cuenta y haga clic en Agregar clave.
Ejecute el comando /connect y busque Nebius Token Factory.
```
/connect
```
Ingrese su clave API de Nebius Token Factory.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo como Kimi K2 Instruct.
```
/models
```

Ollama

Puede configurar opencode para usar modelos locales a travs de Ollama.

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

En este ejemplo:

ollama es el ID de proveedor personalizado. Puede ser cualquier cadena que desee.
npm especifica el paquete a usar para este proveedor. Aqu, @ai-sdk/openai-compatible se usa para cualquier API compatible con OpenAI.
name es el nombre para mostrar del proveedor en la interfaz de usuario.
options.baseURL es el punto final para el servidor local.
models es un mapa de ID de modelo a sus configuraciones. El nombre del modelo se mostrar en la lista de seleccin de modelos.

Ollama Cloud

Para usar Ollama Cloud con OpenCode:

Vaya a https://ollama.com/ e inicie sesin o cree una cuenta.
Navegue a Configuracin > Claves y haga clic en Agregar clave API para generar una nueva clave API.
Copie la clave API para usarla en OpenCode.
Ejecute el comando /connect y busque Ollama Cloud.
```
/connect
```
Ingrese su clave API de Ollama Cloud.
```
┌ API key
│
│
└ enter
```
Importante: Antes de usar modelos en la nube en OpenCode, debe extraer la informacin del modelo localmente:
Ventana de terminal
```
ollama pull gpt-oss:20b-cloud
```
Ejecute el comando /models para seleccionar su modelo de Ollama Cloud.
```
/models
```

OpenAI

Recomendamos suscribirse a ChatGPT Plus o Pro.

Una vez que se haya suscrito, ejecute el comando /connect y seleccione OpenAI.
```
/connect
```
Aqu puede seleccionar la opcin ChatGPT Plus/Pro y esto abrir su navegador y le pedir que se autentique.
```
┌ Select auth method
│
│ ChatGPT Plus/Pro
│ Manually enter API Key
└
```
Ahora todos los modelos de OpenAI deberan estar disponibles cuando use el comando /models.
```
/models
```

Uso de claves API

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

OpenCode Zen

OpenCode Zen es una lista de modelos probados y verificados proporcionados por el equipo de OpenCode. Ms informacin.

Inicie sesin en OpenCode Zen y haga clic en Crear clave API.
Ejecute el comando /connect y busque OpenCode Zen.
```
/connect
```
Ingrese su clave API de OpenCode.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo como Qwen 3 Coder 480B.
```
/models
```

OpenRouter

Vaya al panel de OpenRouter, haga clic en Crear clave API y copie la clave.
Ejecute el comando /connect y busque OpenRouter.
```
/connect
```
Ingrese la clave API del proveedor.
```
┌ API key
│
│
└ enter
```
Muchos modelos de OpenRouter estan precargados de manera predeterminada, ejecute el comando /models para seleccionar el que desea.
```
/models
```
Tambin puede agregar modelos adicionales a travs de su configuracin de opencode.
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openrouter": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}
```

Tambin puede personalizarlos a travs de su configuracin de opencode. Aqu hay un ejemplo de especificar un proveedor

{
  "$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 proporciona acceso a ms de 40 modelos de OpenAI, Anthropic, Google, Amazon, Meta, Mistral y AI21 a travs de una plataforma unificada.

Vaya a su Cockpit de SAP BTP, navegue a su instancia de servicio de SAP AI Core y cree una clave de servicio.

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 el Cockpit de BTP.
Ejecute el comando /connect y busque SAP AI Core.
```
/connect
```

Ingrese su clave de servicio JSON.

┌ Service key
│
│
└ enter

O establezca la variable de entorno AICORE_SERVICE_KEY:

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

O agrgala a su perfil de bash:

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

Opcionalmente, establezca el ID de implementacin y el grupo de recursos:
Ventana de terminal
```
AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode
```
Estas configuraciones son opcionales y deben configurarse segn su configuracin de SAP AI Core.
Ejecute el comando /models para seleccionar entre ms de 40 modelos disponibles.
```
/models
```

OVHcloud AI Endpoints

Vaya al panel de OVHcloud. Navegue a la seccin Public Cloud, AI & Machine Learning > AI Endpoints y en la pestaa API Keys, haga clic en Crear una nueva clave API.
Ejecute el comando /connect y busque OVHcloud AI Endpoints.
```
/connect
```
Ingrese su clave API de OVHcloud AI Endpoints.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo como gpt-oss-120b.
```
/models
```

Scaleway

Para usar las API Generativas de Scaleway con Opencode:

Vaya a la configuracin IAM de la consola de Scaleway para generar una nueva clave API.
Ejecute el comando /connect y busque Scaleway.
```
/connect
```
Ingrese su clave API de Scaleway.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo como devstral-2-123b-instruct-2512 o gpt-oss-120b.
```
/models
```

Together AI

Vaya a la consola de Together AI, cree una cuenta y haga clic en Agregar clave.
Ejecute el comando /connect y busque Together AI.
```
/connect
```
Ingrese su clave API de Together AI.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo como Kimi K2 Instruct.
```
/models
```

Venice AI

Vaya a la consola de Venice AI, cree una cuenta y genere una clave API.
Ejecute el comando /connect y busque Venice AI.
```
/connect
```
Ingrese su clave API de Venice AI.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo como Llama 3.3 70B.
```
/models
```

Vercel AI Gateway

Vercel AI Gateway le permite acceder a modelos de OpenAI, Anthropic, Google, xAI y ms a travs de un punto final unificado. Los modelos se ofrecen al precio de lista sin sobrecargo.

Vaya al panel de Vercel, navegue a la pestaa AI Gateway y haga clic en Claves API para crear una nueva clave API.
Ejecute el comando /connect y busque Vercel AI Gateway.
```
/connect
```
Ingrese su clave API de Vercel AI Gateway.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo.
```
/models
```

También puede personalizar los modelos a travs de su configuracin de opencode. Aqu hay un ejemplo de especificar el orden de enrutamiento del proveedor.

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

Algunas opciones de enrutamiento tiles:

Opcin	Descripcin
`order`	Secuencia de proveedores para intentar
`only`	Restringir a proveedores especficos
`zeroDataRetention`	Usar solo proveedores con polticas de cero retencin de datos

xAI

Vaya a la consola de xAI, cree una cuenta y genere una clave API.
Ejecute el comando /connect y busque xAI.
```
/connect
```
Ingrese su clave API de xAI.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo como Grok Beta.
```
/models
```

Z.AI

Vaya a la consola API de Z.AI, cree una cuenta y haga clic en Crear una nueva clave API.
Ejecute el comando /connect y busque Z.AI.
```
/connect
```
Si est suscrito al Plan de codificacin GLM, seleccione Plan de codificacin Z.AI.
Ingrese su clave API de Z.AI.
```
┌ API key
│
│
└ enter
```
Ejecute el comando /models para seleccionar un modelo como GLM-4.7.
```
/models
```

ZenMux

Vaya al panel de ZenMux, haga clic en Crear clave API y copie la clave.
Ejecute el comando /connect y busque ZenMux.
```
/connect
```
Ingrese la clave API del proveedor.
```
┌ API key
│
│
└ enter
```
Muchos modelos de ZenMux estan precargados de manera predeterminada, ejecute el comando /models para seleccionar el que desea.
```
/models
```
Tambin puede agregar modelos adicionales a travs de su configuracin de opencode.
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "zenmux": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}
```

Proveedor personalizado

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

Ejecute el comando /connect y desplcese hacia abajo a Otro.

$ /connect

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

Ingrese un ID nico para el proveedor.
Ventana de terminal
```
$ /connect

┌  Add credential
│
◇  Enter provider id
│  myprovider
└
```
Elija un ID memorable, lo usar en su archivo de configuracin.

Ingrese su clave API para el proveedor.

$ /connect

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

Cree o actualice su archivo opencode.json en su directorio de proyecto:
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "myprovider": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "My AI ProviderDisplay Name",
      "options": {
        "baseURL": "https://api.myprovider.com/v1"
      },
      "models": {
        "my-model-name": {
          "name": "My Model Display Name"
        }
      }
    }
  }
}
```
Aqu estn las opciones de configuracin:
- npm: Paquete AI SDK para usar, @ai-sdk/openai-compatible para proveedores compatibles con OpenAI
- name: Nombre para mostrar en la interfaz de usuario.
- models: Modelos disponibles.
- options.baseURL: URL del punto final API.
- options.apiKey: Establezca opcionalmente la clave API, si no usa autenticacin.
- options.headers: Establezca opcionalmente encabezados personalizados.
Para ms informacin sobre las opciones avanzadas, consulte el ejemplo a continuacin.
Ejecute el comando /models y su proveedor personalizado y modelos aparecern en la lista de seleccin.

Ejemplo

Aqu hay un ejemplo configurando las opciones apiKey, headers y limit del modelo.

{
  "$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 la configuracin:

apiKey: Establecido usando la sintaxis de variable env, ms informacin.
headers: Encabezados personalizados enviados con cada solicitud.
limit.context: Token de entrada mximo que el modelo acepta.
limit.output: Token mximo que el modelo puede generar.

Los campos limit permiten que OpenCode entienda cunto contexto le queda. Los proveedores estndar los extraen automticamente de models.dev.

Solucin de problemas

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

Verifique la configuracin de autenticacin: Ejecute opencode auth list para ver si las credenciales del proveedor se agregaron a su configuracin.

Esto no se aplica a proveedores como Amazon Bedrock, que dependen de variables de entorno para su autenticacin.
Para proveedores personalizados, verifique la configuracin de opencode y:
- Asegrese de que el ID del proveedor usado en el comando /connect coincida con el ID en su configuracin de opencode.
- Se use el paquete npm correcto para el proveedor. Por ejemplo, use @ai-sdk/cerebras para Cerebras. Y para todos los dems proveedores compatibles con OpenAI, use @ai-sdk/openai-compatible.
- Verifique que se use el punto final API correcto en el campo options.baseURL.