Modelos del clúster.

Modelos de la comunidad. A todos se accede con la misma API compatible con OpenAI y la misma base URL.

glm5.3 - 753B MoE

deepseek-v4-flash - 305B MoE

glm5.3-flash - 320B-18B

qwen3.8-flash - 125B-6B

mimo-v2.6-flash - omnimodal

gemma4 - 26B-A4B

qwen3.6 - 35B-A3B

qwen3-embedding - 8B

rerank - Qwen3-Reranker-8B

kokoro - v1.0

whisper - large-v3

flux-2-klein

qwen-image-2.1

Controlar el razonamiento.

Todos los modelos de chat de arriba razonan antes de responder. El razonamiento llega separado de la respuesta: en message.reasoning_content en Chat Completions y como un elemento de salida reasoning en Responses. Lo controla un único parámetro, igual en todos los modelos:

Los valores, de sin razonamiento al más profundo: none, minimal, low, medium, high, xhigh, max.

Para apagar el razonamiento, envía none. No hace falta nada más. Funciona en todos los modelos salvo GLM, que no puede dejar de razonar (ver la tabla).

El código escrito para otro proveedor sigue funcionando: también aceptamos thinking: {"type": "disabled"}, reasoning: {"enabled": false}, enable_thinking: false y chat_template_kwargs: {"enable_thinking": false}, en el primer nivel del cuerpo o dentro de extra_body. Cada uno significa exactamente none. Si una petición lleva un valor y además uno de estos, gana el valor.

Sin parámetro, todos los modelos razonan (qwen3.6 y gemma4 con un presupuesto de 16.384 tokens). El razonamiento cuesta latencia. Usa solo los valores de esta página. Cualquier otro valor se envía tal cual y queda fuera de este contrato: según el modelo, se rechaza con un 400 o se ignora.

Tu presupuesto de salida (max_tokens o max_completion_tokens en Chat Completions, max_output_tokens en Responses) se usa tal cual lo envías en todos los modelos, salvo por encima del máximo del modelo en dos modelos, donde se baja a ese máximo: 131072 en glm5.3-flash, 393216 en deepseek-v4-flash. Los tokens de razonamiento salen de ese mismo presupuesto.

¿Respuesta vacía con finish_reason: "length"? Con el razonamiento activado, un presupuesto pequeño puede agotarse antes de que empiece la respuesta. En Chat Completions recibes un content vacío con finish_reason: "length", el razonamiento en message.reasoning_content y usage.completion_tokens_details.reasoning_tokens igual a completion_tokens; solo las tres juntas significan que el presupuesto se agotó razonando, y una llamada sin streaming además trae el header de respuesta x-nan-truncated-in-reasoning: true. En Responses la respuesta tiene status: "incomplete" con incomplete_details.reason: "max_output_tokens", solo un elemento de salida reasoning y ningún texto de mensaje, y usage.output_tokens_details.reasoning_tokens es igual a output_tokens. En deepseek-v4-flash un prompt denso puede razonar más de 16k tokens. Si solo necesitas la respuesta, la solución fiable es apagar el razonamiento: reasoning_effort: "none" en Chat Completions, reasoning: {"effort": "none"} en Responses (GLM no puede apagarlo; minimal es lo más corto). Con el razonamiento apagado la respuesta también puede cortarse en el presupuesto, con texto, así que el presupuesto tiene que caberle a la respuesta. Un esfuerzo menor suele razonar menos, pero en deepseek-v4-flash y qwen3.8-flash es una pista, no un tope; solo qwen3.6 y gemma4 lo acotan, en Chat Completions. Para un tope estricto en qwen3.6, gemma4 y qwen3.8-flash, mira Limitar el razonamiento con un presupuesto de tokens. Si quieres el razonamiento, da un presupuesto generoso y usa streaming.

curl https://api.nan.builders/v1/chat/completions \
  -H "Authorization: Bearer $NAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash",
    "reasoning_effort": "none",
    "messages": [{"role": "user", "content": "Write a one-line summary of the CAP theorem."}]
  }'

En Helmcode, usa https://api.helmcode.com/v1 como base URL; todo lo demás es idéntico.

Con el SDK de OpenAI, en Chat Completions y en Responses:

# pip install openai
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["NAN_API_KEY"],
    base_url="https://api.nan.builders/v1",  # Helmcode: https://api.helmcode.com/v1
)

chat = client.chat.completions.create(
    model="deepseek-v4-flash",
    reasoning_effort="none",
    messages=[{"role": "user", "content": "Write a one-line summary of the CAP theorem."}],
)
print(chat.choices[0].message.content)

resp = client.responses.create(
    model="deepseek-v4-flash",
    reasoning={"effort": "none"},
    input="Write a one-line summary of the CAP theorem.",
)
print(resp.output_text)

Si tu versión del SDK de Python todavía no conoce el parámetro (lanza TypeError: ... unexpected keyword argument), envíalo dentro de extra_body; llega a la API exactamente igual:

chat = client.chat.completions.create(
    model="deepseek-v4-flash",
    extra_body={"reasoning_effort": "none"},
    messages=[{"role": "user", "content": "Write a one-line summary of the CAP theorem."}],
)

En Node, con los mismos nombres que la API HTTP:

// npm install openai
import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.NAN_API_KEY,
  baseURL: 'https://api.nan.builders/v1', // Helmcode: https://api.helmcode.com/v1
});

const chat = await client.chat.completions.create({
  model: 'deepseek-v4-flash',
  reasoning_effort: 'none',
  messages: [{ role: 'user', content: 'Write a one-line summary of the CAP theorem.' }],
});
console.log(chat.choices[0].message.content);

const resp = await client.responses.create({
  model: 'deepseek-v4-flash',
  reasoning: { effort: 'none' },
  input: 'Write a one-line summary of the CAP theorem.',
});
console.log(resp.output_text);

TypeScript: si tu versión del SDK tipa el parámetro como una unión a la que le falta un valor que envías (por ejemplo max), añade // @ts-expect-error en la línea de encima, o haz un cast del objeto de parámetros. La API acepta todos los valores de la tabla.

const chat = await client.chat.completions.create({
  model: 'deepseek-v4-flash',
  reasoning_effort: 'max' as any, // older SDK types do not list 'max'
  messages: [{ role: 'user', content: 'Write a one-line summary of the CAP theorem.' }],
});

Limitar el razonamiento con un presupuesto de tokens.

En qwen3.6, gemma4 y qwen3.8-flash también puedes limitar la fase de razonamiento a un número de tokens, en Chat Completions. Envía thinking_token_budget o thinking_budget: son dos nombres del mismo parámetro, así que usa el que ya envíe tu código. Cada modelo recibe el nombre que entiende. Ponlo en el primer nivel del cuerpo o dentro de extra_body.

• Un entero de 1 a 32768 limita el razonamiento a ese número de tokens. Es un tope estricto: el modelo deja de razonar ahí y escribe su respuesta.
• 0 apaga el razonamiento, igual que reasoning_effort: "none".
• En NaN, un valor mayor (o que no sea un entero) se reduce a 32768.

Envía un presupuesto o reasoning_effort, no los dos: combinados, el resultado depende del modelo. En el resto de modelos el presupuesto no forma parte de este contrato (según el modelo se rechaza con un 400 o se ignora); usa reasoning_effort. En Responses el presupuesto no está garantizado; usa reasoning: {"effort": ...}.

curl https://api.nan.builders/v1/chat/completions \
  -H "Authorization: Bearer $NAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8-flash",
    "thinking_budget": 2048,
    "messages": [{"role": "user", "content": "How many primes are there below 200?"}]
  }'

Con el SDK de OpenAI va por extra_body:

chat = client.chat.completions.create(
    model="qwen3.8-flash",
    extra_body={"thinking_budget": 2048},
    messages=[{"role": "user", "content": "How many primes are there below 200?"}],
)

Respuestas largas: usa streaming.

Una petición sin stream: true no devuelve nada hasta que la respuesta completa está lista, y tiene que estar lista en 120 segundos. Pasado ese tiempo la conexión se cierra con un 524 (o con un error unos segundos antes), sea cual sea el modelo. A la velocidad de deepseek-v4-flash eso son unos 10.000 a 15.000 tokens de salida; los modelos más lentos, y los modelos con razonamiento, que piensan antes de responder, caben en menos.

Si pides respuestas largas (un max_tokens grande, ficheros de código largos, agentes que escriben documentos enteros), usa stream: true. Un stream no tiene límite de tiempo total mientras siga produciendo: los tokens te llegan a medida que se generan, dure lo que dure la respuesta. La única excepción es un turno que solo produce razonamiento durante mucho tiempo, mira el límite de stream solo-razonamiento más abajo. Todos los modelos de chat soportan streaming en los dos endpoints (/v1/chat/completions y /v1/responses).

Límite de stream solo-razonamiento.

Los prompts que exigen mucho razonamiento pueden dejar al modelo pensando mucho tiempo antes de escribir nada. Cuando un turno en streaming produjo solo razonamiento — sin content ni tool calls — durante 420 segundos, la plataforma cierra el turno en lugar de dejarlo correr hacia un callejón sin salida. Un turno que demuestra que está pensando — ya produjo más de 45.000 caracteres de razonamiento — tiene hasta 600 segundos. El presupuesto de caracteres de razonamiento también escala con el tamaño de tu prompt: unos 150.000 caracteres de margen más la mitad del tamaño del prompt en caracteres, con un tope de 300.000. Cuando la plataforma cierra el turno recibes finish_reason: "length" sobre un delta vacío, seguido de un chunk de usage.

Ese chunk de usage es una estimación de lo que consumió el intento hasta el corte (tokens de prompt y de razonamiento), marcada con "estimated": true, "billed": false — los turnos cerrados así no se cobran de tu cuota — y lleva un marcador nan_truncation para que los clientes puedan distinguir este cierre de un corte real por longitud de contexto. Pídelo con stream_options: {"include_usage": true}.

Dos cosas que conviene saber:

• El límite no acota tu output. El primer token visible de contenido o cualquier tool call lo desarma por el resto del turno: las respuestas que escriben sobre la marcha nunca se cortan, por largas que sean.
• Si un turno se cierra así, el modelo seguía planificando cuando tocó el techo. Baja reasoning_effort donde el modelo lo soporte (tabla de arriba), o reestructura el prompt para que empiece a escribir temprano.

El límite existe para acotar un modo de fallo conocido de los modelos con thinking: a veces planifican sin converger durante 10–25 minutos y queman todo su presupuesto de output sin output visible. Los topes están por encima de las trazas de razonamiento de los turnos sanos que convergen en nuestro tráfico de producción, y solo se endurecen cuando un stream está atascado.

Límites de peticiones