> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kodus.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Moonshot (Kimi) - Inferencia Compatible con OpenAI

> Aprende a conectar los modelos Kimi K2.6 de Moonshot AI a Kodus — a través del Developer API de Moonshot o el Kimi Code Plan.

## Cómo funciona Moonshot

Moonshot AI publica la familia de modelos **Kimi** (K2, K2.5, K2.6, K2.6 Coding). Kimi es particularmente robusto en comprensión de código de contexto largo y flujos de trabajo agénticos, y la API es totalmente compatible con OpenAI — Kodus puede comunicarse con ella a través del proveedor **OpenAI-compatible**. Kodus también tiene un proveedor dedicado **Moonshot**, que se conecta mediante el endpoint compatible con Anthropic de Moonshot (`https://api.moonshot.ai/anthropic`).

Moonshot ofrece **dos rutas** a la misma familia de modelos, cada una con su propio endpoint:

* **Developer API** (`platform.moonshot.ai`) — pago por token, facturado por uso. La concurrencia escala con tu nivel de recarga.
* **Kimi Code Plan** (`kimi.com/code`) — suscripción con **endpoint de código dedicado**. Precio fijo, concurrencia limitada (30 concurrentes).

> [!NOTE]
>
> Las suscripciones de consumidor del chat Kimi.com de Moonshot (Andante, Moderato, etc.) son independientes de ambas rutas de API. Las suscripciones de chat **no** otorgan acceso a la API. El Kimi Code Plan es la suscripción específica para API.

Moonshot también opera una plataforma exclusiva para China (`platform.moonshot.cn`, URL base `https://api.moonshot.cn/v1`) facturada en CNY. Úsala solo si operas dentro de China continental.

## Planes de un vistazo

### Kimi Code Plan (suscripción)

| Atributo | Valor |
| - | - |
| **Endpoint** | `https://api.kimi.com/coding/v1` |
| **Concurrencia** | Limitada a 30 solicitudes concurrentes |
| **Facturación** | Suscripción a tarifa plana |
| **Claves desde** | [kimi.com/code](https://www.kimi.com/code) |

### Developer API (pago por token)

| Modelo | Precio (1M tokens de entrada / salida) | Ventana de contexto | Notas |
| - | - | - | - |
| **Kimi K2.6 Coding** `recomendado` | \~$0.60 / $2.50 | \~256k tokens | Último, ajustado para revisión de código. |
| **Kimi K2.5** | $0.60 / $2.50 | \~256k tokens | Generación anterior, aún capaz. |
| **Kimi K2 (0905)** | nivel inferior | \~128k tokens | Modelo estable de propósito general. |

Endpoint del Developer API: `https://api.moonshot.ai/v1` (internacional). La concurrencia escala con el nivel de recarga — Tier 1 (recarga de \$10) empieza en \~50 concurrentes, hasta \~1000 concurrentes en Tier 5.

## Crear una clave de API

> [!WARNING]
>
> Se requiere una cuenta de Moonshot para crear una clave de API.

**Suscriptor del Kimi Code Plan**

1. Ve a [kimi.com/code](https://www.kimi.com/code) y suscríbete al plan.
2. Abre el área de gestión de claves para tu suscripción.
3. Crea una clave de Kimi Code y cópiala.

> [!NOTE]
>
> Las claves de Kimi Code solo funcionan contra `https://api.kimi.com/coding/v1`. Devolverán 401 si se envían a `api.moonshot.ai`.

**Developer API (pago por token)**

1. Inicia sesión en [platform.moonshot.ai](https://platform.moonshot.ai) (o [platform.moonshot.cn](https://platform.moonshot.cn) si operas dentro de China continental).
2. Agrega un método de pago — Moonshot puede otorgar un pequeño saldo inicial cuando agregas facturación por primera vez.
3. Abre la sección **API Keys** en [platform.moonshot.ai/console/api-keys](https://platform.moonshot.ai/console/api-keys).
4. Haz clic en **Create API Key**, dale un nombre descriptivo (por ejemplo, `kodus-prod`) y copia la clave de inmediato.

> [!NOTE]
>
> Las claves del Developer API solo funcionan contra `api.moonshot.ai/v1` (internacional) o `api.moonshot.cn/v1` (China). Las claves **no** son portables entre regiones.

## Configurar Moonshot en Kodus

El flujo principal es la página **AI providers** en Kodus Cloud. Los usuarios con alojamiento autónomo que prefieren fijar el proveedor a nivel de proceso pueden usar variables de entorno en su lugar.

### Opción 1 — Proveedor Moonshot en Kodus Cloud (recomendado para el Developer API)

**1. Abrir AI providers y elegir Moonshot**

En la barra lateral, abre **AI providers** ([app.kodus.io/byok](https://app.kodus.io/byok)). En la pestaña **Providers**, haz clic en el mosaico **Moonshot** (en **Connect your first provider**, o en **Add another provider** si ya conectaste uno).

**2. Pegar tu clave de API y elegir el modelo**

Pega tu clave del Developer API de [platform.moonshot.ai](https://platform.moonshot.ai/console/api-keys) en la tarjeta **API key**. El selector **Model** carga entonces los modelos de Moonshot — elige uno (por ejemplo, `kimi-k2.6`) o selecciona **Type model manually**. Kodus completa el endpoint `https://api.moonshot.ai/anthropic` por ti; este mosaico no tiene selector de plan ni campo de URL base, así que para una clave del Kimi Code Plan (o la plataforma de China) usa la Opción 2 más abajo.

**3. Probar y guardar**

Haz clic en **Test & save**. Kodus prueba la conexión y guarda la configuración si tiene éxito. 401 significa que la clave no coincide con el endpoint.

### Ajustar el razonamiento (opcional)

**Thinking / Reasoning** está en **Advanced (optional)**. Para Kimi, cualquier nivel distinto de Off emite `thinking: { type: "enabled" }`. Para sobrescribirlo, cambia **Thinking / Reasoning** a **Custom** y pega uno de estos:

* **Deshabilitar el pensamiento** para revisiones más rápidas/económicas en PRs pequeños:

  ```json theme={null}
  {
    "thinking": { "type": "disabled" }
  }
  ```

* **Forzar un presupuesto específico de tokens** (si Moonshot agrega soporte para `budget_tokens` en tu nivel):

  ```json theme={null}
  {
    "thinking": { "type": "enabled", "budget_tokens": 25000 }
  }
  ```

> [!NOTE]
>
> No necesitas envolver en namespace — Kodus envuelve las opciones bajo el namespace del provider activo antes de enviar. Consulta [main BYOK doc → Custom JSON override](https://docs.kodus.io/es/how_to_use/byok.md#sobrescritura-con-json-personalizado) para más detalles.

### Ajustar la concurrencia

* **Kimi Code Plan**: define **Max concurrent requests** (en **Advanced (optional)**) en `30` (el tope documentado). Subirlo devuelve 429.
* **Developer API**: empieza vacío (sin tope). Tu límite real escala con tu nivel de recarga — Tier 1 (\~$10 de recarga) permite ~50 concurrentes; Tier 5 (~$3000) permite \~1000. Bájalo explícitamente si ves errores 429 durante las revisiones.

> [!NOTE]
>
> En la pestaña **Routing**, define Kimi como **Model for all tasks** y un modelo de OpenAI o Anthropic como **Fallback (optional)** — si Moonshot devuelve 429 o 402, Kodus conmuta automáticamente.

### Opción 2 — Endpoint compatible con OpenAI

Para el Kimi Code Plan, la plataforma de China o el endpoint compatible con OpenAI de Moonshot, abre **AI providers**, elige **OpenAI-compatible** en **Custom** en la pestaña **Providers** y completa:

| Campo | Valor |
| - | - |
| **Base URL** | `https://api.moonshot.ai/v1` (Developer API) `https://api.kimi.com/coding/v1` (Kimi Code Plan) `https://api.moonshot.cn/v1` (solo China continental) |
| **Model** | `kimi-k2.6`, `kimi-k2.6`, `kimi-k2.5`, `kimi-k2-0905`, `kimi-k2` |
| **API key** | tu clave de Moonshot o Kimi Code (coincidiendo con la URL base de arriba) |
| **Max concurrent requests** (en **Advanced (optional)**) | `30` en Kimi Code Plan; déjalo vacío en Developer API (escala con el nivel de recarga) |

### Opción 3 — Alojamiento autónomo (variables de entorno)

Si ejecutas Kodus en Modo Fijo (proveedor global único, sin BYOK por organización), configura Moonshot en el `.env` de tus contenedores de API + worker:

```env theme={null}
# Configuración de Moonshot (Kimi) (Modo Fijo)
API_LLM_PROVIDER_MODEL="kimi-k2.6"
API_OPENAI_FORCE_BASE_URL="https://api.moonshot.ai/v1"    # o https://api.kimi.com/coding/v1 para Kimi Code Plan
API_OPEN_AI_API_KEY="your-moonshot-or-kimi-code-api-key"
```

> [!NOTE]
>
> Esta opción solo es necesaria para instalaciones de Kodus con alojamiento autónomo que deshabilitan deliberadamente el BYOK. Si el BYOK está habilitado en tu instancia con alojamiento autónomo, prefiere la **Opción 1** o la **Opción 2** — la página **AI providers** funciona igual que en Cloud.

Reinicia los contenedores de API y worker después de editar `.env`, luego verifica la integración:

```bash theme={null}
docker-compose logs api worker | grep -iE "moonshot|kimi"
```

Para la configuración completa con alojamiento autónomo (dominios, claves de seguridad, base de datos, webhooks, proxy inverso), sigue la [guía de despliegue en VM genérica](https://docs.kodus.io/es/how_to_deploy/deploy_kodus/generic_vm.md) y solo reemplaza el bloque LLM con el anterior.

## Elegir entre Kimi Code Plan, Developer API y agregadores

* **Kimi Code Plan** — costo fijo predecible, tope de 30 concurrentes, endpoint dedicado `api.kimi.com/coding/v1` optimizado para flujos de trabajo de codificación. Ideal para equipos estables con volumen de PR predecible.
* **Moonshot Developer API** — pago por token, la concurrencia escala con el nivel de recarga, máxima flexibilidad. Ideal para cargas variables.
* **Proxy de OpenRouter** — si quieres una sola relación de facturación entre muchos proveedores, OpenRouter expone los modelos de Kimi con un pequeño margen de enrutamiento. Elige esto cuando Kimi sea parte de una flota mixta de proveedores, no una carga de trabajo primaria.

## Solución de problemas

> **401 después de Test — la clave no coincide con el endpoint**
>
> * Las claves del Kimi Code Plan solo funcionan contra `api.kimi.com/coding/v1`.
> * Las claves del Developer API de `platform.moonshot.ai` solo funcionan contra `api.moonshot.ai/v1`.
> * Las claves del Developer API de `platform.moonshot.cn` solo funcionan contra `api.moonshot.cn/v1`.
> * El mosaico **Moonshot** siempre usa `https://api.moonshot.ai/anthropic`, así que necesita una clave de `platform.moonshot.ai`. Conecta las claves del Kimi Code Plan o de `platform.moonshot.cn` mediante **OpenAI-compatible** con la **Base URL** correspondiente.

> **Saldo insuficiente**
>
> * El Developer API factura por token. Si el saldo se agota, las solicitudes devuelven HTTP 402.
> * Agrega fondos en la sección de facturación de la consola o establece un tope mensual para evitar sorpresas.
> * El Kimi Code Plan tiene precio fijo pero está limitado por su tope de 30 concurrentes y ventanas de cuota — 429 significa que has alcanzado uno.

> **Modelo no encontrado**
>
> * Confirma que el nombre del modelo coincida con el catálogo (`kimi-k2.6`, `kimi-k2.6`, `kimi-k2.5`, `kimi-k2-0905`, `kimi-k2`).
> * Consulta [platform.kimi.ai/docs](https://platform.kimi.ai/docs) para la lista actual — las nuevas versiones se lanzan regularmente.

> **Primera respuesta lenta**
>
> * La primera llamada después de períodos de inactividad puede tener un arranque en frío por parte de Moonshot.
> * Si la latencia importa, `kimi-k2-0905` es generalmente más rápido que las variantes K2.6 para revisiones rutinarias.

> **Región / conectividad**
>
> * Los usuarios fuera de China siempre deben usar `api.moonshot.ai` o `api.kimi.com`. `api.moonshot.cn` puede ser inaccesible o estar limitado por tasa desde fuera de China continental.
> * Confirma que el HTTPS saliente hacia el endpoint elegido esté permitido desde tu despliegue de Kodus.

## Relacionado

* [Plataforma de Moonshot (internacional)](https://platform.moonshot.ai)
* [Kimi Code Plan](https://www.kimi.com/code)
* [Documentación de la API de Kimi](https://platform.kimi.ai/docs)
* [Resumen de BYOK](https://docs.kodus.io/es/how_to_use/byok.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.