Índice de Documentación
Obtén el índice completo de documentación en: https://docs.aihubmix.com/llms.txt
Utiliza este archivo para descubrir todas las páginas disponibles antes de explorar más.

Guía de Kimi K3 de julio de 2026: max de esfuerzo de razonamiento, historial de pensamiento, carga dinámica de herramientas, salida estructurada, almacenamiento en caché automático, prefijo parcial e inputs de visión.

Este artículo cubre los nuevos parámetros y notas de uso para Kimi K3. En AIHubMix, K3 está disponible a través de las APIs de Completions de Chat, Respuestas y Mensajes compatibles con Claude. Ver también: documentación oficial de la plataforma Moonshot.

Las conclusiones y respuestas de muestra "Verificadas" en cada sección provienen de llamadas reales realizadas el 2026-07-17 a través de las APIs de AIHubMix (Completions de Chat / Respuestas / Mensajes).

1. Especificaciones del Modelo a Primera Vista

Verificado: ambos límites de stop están validados, y exceder cualquiera devuelve 400; la API de Mensajes aplica la misma validación a stop_sequences.

❗ Cuando se alcanza una secuencia de parada, la API de Mensajes no sigue la semántica de Anthropic: en las pruebas, stop_reason es "end_turn" (en lugar de "stop_sequence"), stop_sequence es null, y el texto visible antes de la palabra de parada puede estar vacío. Los clientes que dependen de estos dos campos para detectar truncamientos deben tener en cuenta esto.

# stop con 6 entradas / una entrada de 33 bytes -> HTTP 400
"Solicitud inválida: el arreglo de stop es demasiado largo. Se esperaba un arreglo con una longitud máxima de 5, pero se obtuvo un arreglo con longitud 6 en su lugar"
"Solicitud inválida: la secuencia de parada no debe ser más larga de 32, pero se obtuvo 33 en su lugar"

2. Modo de Pensamiento: reasoning_effort Solo Soporta max

El pensamiento de K3 está activado por defecto, y reasoning_effort solo admite un único nivel: "max".

Las conversaciones de múltiples turnos deben devolver el historial de pensamiento de forma veraz: según la documentación oficial de Moonshot, K3 está entrenado con el pensamiento preservado, por lo que en conversaciones de múltiples turnos el mensaje anterior del asistente debe ser devuelto completo y sin modificar (incluido el contenido de pensamiento). La falta de historial de pensamiento conduce a una calidad de salida inestable. Si utilizas un marco de gestión de sesiones o una capa de proxy, confirma que el contenido de pensamiento se devuelva sin recortes.

El contenido de pensamiento se devuelve en el campo `reasoning_content` de la respuesta; en conversaciones de múltiples turnos, pasa el mensaje anterior del asistente (incluido `reasoning_content`) de forma veraz.

```text theme={null}
from openai import OpenAI

client = OpenAI(
    base_url="https://aihubmix.com/v1",
    api_key="<AIHUBMIX_API_KEY>",
)

completion = client.chat.completions.create(
    model="kimi-k3",
    reasoning_effort="max",
    messages=[
        {"role": "user", "content": "Un caracol está en el fondo de un pozo de 10 metros. Cada día sube 3 metros, pero cada noche resbala 2 metros. ¿Cuántos días tarda en llegar a la cima?"}
    ],
)

print(completion.choices[0].message.reasoning_content)
print(completion.choices[0].message.content)
```

```text theme={null}
# Conversaciones de múltiples turnos: pasa el mensaje anterior del asistente de forma veraz
messages = [
    {"role": "user", "content": "¿Cuál es la capital de Francia?"},
    {"role": "assistant", "content": "París.", "reasoning_content": "<reasoning_content de la respuesta anterior>"},
    {"role": "user", "content": "¿Y su población?"},
]
```

> **Verificado**: la respuesta devuelve `reasoning_content`; después de pasar el mensaje anterior del asistente (incluido `reasoning_content`) de forma veraz, los turnos subsiguientes responden normalmente.

El contenido de pensamiento se devuelve como un ítem de salida `reasoning`; en conversaciones de múltiples turnos, añade los ítems de salida del turno anterior (`reasoning` + `message`) de vuelta en `input` de forma veraz.

```text theme={null}
from openai import OpenAI

client = OpenAI(
    base_url="https://aihubmix.com/v1",
    api_key="<AIHUBMIX_API_KEY>",
)

response = client.responses.create(
    model="kimi-k3",
    input="Responde en una palabra: capital de Francia",
)

# Tipos de ítems de respuesta.output observados: ["reasoning", "message"]; texto: "París"
# Conversaciones de múltiples turnos: input = [primer mensaje del usuario] + response.output + [siguiente mensaje del usuario]
# Respuesta observada en el segundo turno con ítems de salida devueltos: "Berlín"
```

El contenido de pensamiento se devuelve como bloques de contenido `thinking` nativos; en conversaciones de múltiples turnos, pasa los bloques de contenido del asistente anteriores (incluidos los bloques de pensamiento) de vuelta de forma veraz.

```text theme={null}
from anthropic import Anthropic

client = Anthropic(
    api_key="<AIHUBMIX_API_KEY>",
    base_url="https://aihubmix.com"
)

response = client.messages.create(
    model="kimi-k3",
    max_tokens=4096,
    messages=[
        {"role": "user", "content": "Responde en una palabra: capital de Francia"}
    ],
)

# Tipos de bloques de respuesta.content observados: ["thinking", "text"]; texto: "París"
# Conversaciones de múltiples turnos: pasa response.content de vuelta de forma veraz como el mensaje del asistente
```

3. Los Parámetros de Muestreo Son Fijos

Los parámetros de muestreo de K3 son fijos por el proveedor: temperature 1.0, top_p 0.95, n 1, y presence_penalty / frequency_penalty 0. La recomendación oficial es omitir estos parámetros de las solicitudes.

Nota: los valores de muestreo fijos son parte de la especificación oficial y no pueden ser verificados a partir de señales de respuesta; sigue la recomendación oficial y omite estos parámetros.

4. Llamadas a Herramientas y Carga Dinámica de Herramientas

tools admite hasta 128 herramientas; tool_choice permite forzar y deshabilitar llamadas a herramientas. K3 también admite carga dinámica de herramientas: inyectar nuevas herramientas en medio de la conversación a través del campo tools de un mensaje del sistema (una forma de mensaje específica de la API de Chat).

`tool_choice` admite `auto` / `none` / `required`; `required` obliga al modelo a llamar a una herramienta. Carga dinámica de herramientas: el mensaje del sistema que inyecta la herramienta no lleva `content`, las herramientas inyectadas tienen efecto para los turnos subsiguientes, y el mensaje debe incluirse nuevamente en cada solicitud.

```text theme={null}
messages = [
    {"role": "system", "content": "Eres un asistente útil."},
    {"role": "user", "content": "Hola."},
    {"role": "assistant", "content": "Hola, ¿cómo puedo ayudarte?"},
    # Inyectar una nueva herramienta en medio de la conversación: solo campo de herramientas, sin contenido
    {
        "role": "system",
        "tools": [
            {
                "type": "function",
                "function": {
                    "name": "get_time",
                    "description": "Obtener la hora actual",
                    "parameters": {"type": "object", "properties": {}},
                },
            }
        ],
    },
    {"role": "user", "content": "¿Qué hora es ahora?"},
]
```

```text theme={null}
# tool_choice="required" con el aviso "Hola" -> el modelo está obligado a llamar a la herramienta
"finish_reason": "tool_calls",
"tool_calls": [{"function": {"name": "get_weather", "arguments": "{\"city\":\"Nueva York\"}"}}]
```

> **Verificado**: `tool_choice: "required"` obliga a una llamada a la herramienta incluso para avisos no relacionados; `"none"` suprime las llamadas a herramientas; las herramientas inyectadas en medio de la conversación a través de un mensaje del sistema sin `content` pueden ser llamadas normalmente.

Las definiciones de herramientas utilizan una estructura plana (`name` en el nivel superior); forzar una llamada también utiliza `tool_choice: "required"`, y las llamadas se devuelven como ítems de salida `function_call`. El soporte para carga dinámica de herramientas está en progreso; por ahora, declara todas las herramientas en el parámetro `tools` de nivel superior.

```text theme={null}
response = client.responses.create(
    model="kimi-k3",
    input="Hola",
    tools=[{
        "type": "function",
        "name": "get_weather",
        "description": "Obtener el clima para una ciudad",
        "parameters": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
    }],
    tool_choice="required",
)

# La salida observada contiene: {"type": "function_call", "name": "get_weather", "arguments": "{\"city\":\"Londres\"}"}
```

Las herramientas utilizan el formato de Anthropic (`input_schema`); fuerza una llamada con `tool_choice: {"type": "any"}` y desactiva llamadas con `{"type": "none"}`. ❗ **El endpoint oficial de Mensajes de Kimi K3 (compatible con Anthropic) no admite carga dinámica de herramientas**: en las pruebas, el mensaje inyectado devuelve 200, pero la herramienta inyectada no tiene efecto (el modelo no puede llamarla). Declara todas las herramientas en el parámetro `tools` de nivel superior.

```text theme={null}
response = client.messages.create(
    model="kimi-k3",
    max_tokens=4096,
    tools=[{
        "name": "get_weather",
        "description": "Obtener el clima para una ciudad",
        "input_schema": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
    }],
    tool_choice={"type": "any"},
    messages=[{"role": "user", "content": "Hola"}],
)

# Observado: stop_reason "tool_use"; el contenido contiene un bloque de tool_use llamando a get_weather
```

5. Salida Estructurada

La salida estructurada hace que el modelo devuelva contenido que se ajusta estrictamente a un esquema JSON dado.

`response_format` admite `json_schema` con modo `strict`.

```text theme={null}
completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "user", "content": "París es la capital de Francia. Extrae el nombre de la ciudad."}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "extract",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"],
            },
        },
    },
)

# Contenido de respuesta observado: {"city":"París"}
```

> **Verificado**: la salida es un JSON válido que se ajusta al esquema.

La salida estructurada se declara a través de `text.format`.

```text theme={null}
response = client.responses.create(
    model="kimi-k3",
    input="París es la capital de Francia. Extrae el nombre de la ciudad.",
    text={
        "format": {
            "type": "json_schema",
            "name": "extract",
            "strict": True,
            "schema": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
        }
    },
)

# Texto de salida observado: {"city":"París"}
```

❗ **El endpoint oficial de Mensajes de Kimi K3 (compatible con Anthropic) no admite salida estructurada**: los campos de salida estructurada son ignorados silenciosamente — la solicitud devuelve HTTP 200 con texto libre, sin error o aviso de retroceso, y el análisis JSON posterior fallará. Cuando necesites salida estructurada, utiliza la API de Completions de Chat o la API de Respuestas.

6. El Almacenamiento en Caché de Contexto es Automático

El almacenamiento en caché de contexto de K3 se activa automáticamente, sin parámetros requeridos. Cuando un prefijo largo repetido alcanza la caché, la cantidad de aciertos se informa en el uso (el nombre del campo varía según la API). Los precios de caché están en la página del modelo.

```text theme={null} # uso de la segunda llamada con un prefijo largo idéntico "prompt_tokens_details": {"cached_tokens": 1536} ```

> **Verificado**: la segunda solicitud con un prefijo largo idéntico informa el acierto en `usage.prompt_tokens_details.cached_tokens`.

```text theme={null} # uso de la segunda llamada de Respuestas con instrucciones largas idénticas "input_tokens_details": {"cached_tokens": 1536} ``` ```text theme={null} # uso de la segunda llamada de Mensajes con un aviso de sistema largo idéntico "cache_read_input_tokens": 1536 ```

7. Compleción de Prefijo partial

La completación de prefijo hace que el modelo continúe generando desde un prefijo dado, adecuado para la completación de código y salida controlada por formato.

Pasa `"partial": true` en el último mensaje del asistente.

```text theme={null}
messages = [
    {"role": "user", "content": "Escribe un haiku sobre el mar."},
    {"role": "assistant", "content": "Las olas se pliegan en espuma,", "partial": True},
]

# Prefijo: "Las olas se pliegan en espuma,"  ->  continuación devuelta por el modelo
# la sal flota en el aire—
# la luna atrae la marea a casa.
```

> **Verificado**: la generación continúa desde el prefijo dado sin repetirlo.

Pasa el prefijo como un mensaje del asistente al final del array de `input`; no se necesita ningún parámetro `partial`.

```text theme={null}
response = client.responses.create(
    model="kimi-k3",
    input=[
        {"role": "user", "content": "Escribe un haiku sobre el mar."},
        {"role": "assistant", "content": "Las olas se pliegan en espuma,"},
    ],
)

# Continuación observada: "la sal flota en el aire— / la luna atrae la marea a casa."
```

La misma capacidad se logra con el autocompletado nativo del asistente del protocolo, sin necesidad de un parámetro `partial` — pasa el prefijo como el último mensaje del asistente.

```text theme={null}
response = client.messages.create(
    model="kimi-k3",
    max_tokens=4096,
    messages=[
        {"role": "user", "content": "Escribe un haiku sobre el mar."},
        {"role": "assistant", "content": "Las olas se pliegan en espuma,"},
    ],
)

# Continuación observada: "el viento salado lleva el grito de la gaviota— / la marea tira ..."
```

8. Entrada de Visión

Las imágenes se pasan como base64; el formato del bloque de contenido varía según la API.

```text theme={null} messages = [ { "role": "user", "content": [ {"type": "text", "text": "¿Cuál es el color dominante de esta imagen? Una palabra."}, {"type": "image_url", "image_url": {"url": "data:image/png;base64,"}}, ], } ]

# Contenido de respuesta observado: "Rojo"  (entrada: un PNG sólido rojo de 64x64)
```

> **Verificado**: la entrada de imagen en base64 funciona, y el modelo describe correctamente la imagen de prueba.

```text theme={null} input = [ { "role": "user", "content": [ {"type": "input_text", "text": "¿Cuál es el color dominante de esta imagen? Una palabra."}, {"type": "input_image", "image_url": "data:image/png;base64,"}, ], } ]

# Texto de salida observado: "Rojo"
```

```text theme={null} messages = [ { "role": "user", "content": [ {"type": "text", "text": "¿Cuál es el color dominante de esta imagen? Una palabra."}, {"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": ""}}, ], } ]

# Texto de respuesta observado: "Rojo"
```

9. Referencia Verificada: Latencia y Uso de una Tarea Larga de Llamada Única

El pensamiento de K3 está fijado en el nivel máximo, por lo que las solicitudes únicas para tareas complejas tardan significativamente más que en modelos típicos. Datos medidos de una tarea de generación de juego HTML de un solo archivo (un aviso con una imagen de referencia, generado en una sola vez sin iteración): la solicitud única tomó 2,541 segundos (aproximadamente 42 minutos), con 74,994 tokens de completación, de los cuales 54,486 (73%) fueron tokens de pensamiento; la salida final fue de 1,275 líneas de código ejecutable directamente, con finish_reason stop.

Recomendaciones del lado del cliente:

• Establecer los tiempos de espera del cliente en minutos o más, y preferir el streaming para tareas largas;
• Dejar suficiente margen en max_completion_tokens — en este caso, el pensamiento solo consumió 54,486 tokens.

10. Matriz de Soporte de Capacidad × API

Cada celda en la tabla a continuación fue verificada el 2026-07-17 a través de llamadas reales a las APIs de producción de AIHubMix; cada celda muestra la sintaxis de parámetro / campo para la API correspondiente.

FAQ

¿Qué APIs soporta K3 en AIHubMix?
Completions de Chat (/v1/chat/completions), Respuestas (/v1/responses), y la API de Mensajes compatible con Claude (/v1/messages).

¿Se puede desactivar o reducir el pensamiento?
No. El pensamiento de K3 está activado por defecto, y reasoning_effort solo admite el único nivel "max".

¿Por qué debe devolverse reasoning_content en conversaciones de múltiples turnos?
K3 está entrenado con pensamiento preservado; Moonshot requiere que el mensaje anterior del asistente se devuelva completo y sin modificar. La falta de historial de pensamiento conduce a una calidad de salida inestable.

¿Cuáles son los límites en el parámetro stop?
Como máximo 5 secuencias de parada, cada una no mayor de 32 bytes; exceder cualquiera de los límites devuelve un error 400.

¿La API de Mensajes admite salida estructurada?
❗ No. El endpoint oficial de Mensajes de Kimi K3 ignora silenciosamente los campos de salida estructurada (devolviendo 200 con texto libre y sin error). Para salida estructurada, utiliza response_format en Completions de Chat o text.format en Respuestas.

¿Por qué tardan tanto las solicitudes únicas de K3?
El pensamiento de K3 está fijado en el nivel máximo, y los tokens de pensamiento constituyen una gran parte en tareas complejas (73% de los tokens de completación en el caso medido). Establece los tiempos de espera del cliente en minutos o más y utiliza streaming.

Para precios y estado en tiempo real, consulta la página del modelo Kimi K3; para más modelos, visita la galería de modelos.

Última actualización: 2026-07-17