Cómo configurar el esfuerzo de razonamiento de DeepSeek V4.1 Flash en cualquier API compatible con OpenAI

DeepSeek V4.1 Flash razona antes de responder. A menos que indiques lo contrario, razona con esfuerzo high. Puedes cambiarlo con un campo de la solicitud, reasoning_effort. Es un campo normal en el cuerpo de la solicitud, así que puedes definirlo por solicitud a través de cualquier endpoint que lo pase, incluido el nuestro. No necesitas un model ID diferente.

Este artículo cubre los cuatro niveles, cuánto costó cada uno en una prueba que hicimos el 16 de octubre de 2026, cómo definir el campo desde código y desde herramientas comunes, y cómo verificar que un endpoint de terceros realmente lo pase.

La versión corta

Agrega reasoning_effort junto a model:

curl https://api.cheapaimodel.ai/v1/chat/completions \
  -H "Authorization: Bearer $CHEAPAIMODEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-1-flash",
    "reasoning_effort": "low",
    "messages": [{"role": "user", "content": "Summarize this changelog in three bullets: ..."}]
  }'

Valor	Qué hace
none	Desactiva el razonamiento. El modelo responde de inmediato.
low	Razonamiento corto. DeepSeek lo sugiere para tareas simples.
high	El predeterminado. DeepSeek lo sugiere para trabajo de agente cotidiano.
max	El razonamiento más largo, para problemas más difíciles.

Omitir el campo es lo mismo que enviar high.

Cuánto costó cada nivel

Enviamos una pregunta de matemáticas con una sola respuesta correcta a https://api.cheapaimodel.ai/v1: ¿cuántos pares ordenados (a, b) de enteros positivos, ambos como máximo 100, hacen que a² + b² sea divisible entre 13? (La respuesta es 1,491). Cada nivel se ejecutó 8 veces, excepto none, que se ejecutó 3 veces. Todas las solicitudes fueron sin streaming.

Esfuerzo	Promedio de tokens de razonamiento	Rango	Tiempo promedio	Correctas
none	0	0	14.0 s	0 de 3
low	2,348	925–3,719	17.2 s	7 de 8
high	3,081	2,232–3,629	20.4 s	8 de 8
max	3,530	2,700–5,803	23.2 s	7 de 8

Los tokens de razonamiento se cobran como tokens de salida. Con nuestro precio de V4.1 Flash cuando hicimos la prueba, US$0.84 por millón de tokens de salida, una solicitud promedio costó alrededor de US$0.002 con low y US$0.003 con max.

Lo que destacó:

• Con el razonamiento desactivado, el modelo se equivocó todas las veces. Dos veces ignoró "responde solo con el número" y resolvió el problema en su respuesta visible, lo que tardó casi lo mismo que habría tardado el razonamiento.
• high y max fueron similares en esta pregunta. max gastó claramente más solo una vez, cuando eligió pensar mucho más (la ejecución de 5,803 tokens).
• low usó alrededor de una cuarta parte menos de tokens que high y falló una vez.

Una pregunta no es un benchmark. Antes de elegir un predeterminado, ejecuta una muestra de tus propias prompts en dos niveles y compara usage.completion_tokens_details.reasoning_tokens y las respuestas.

Definirlo desde código

SDK de OpenAI para Python

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cheapaimodel.ai/v1",
    api_key=os.environ["CHEAPAIMODEL_API_KEY"],
)

completion = client.chat.completions.create(
    model="deepseek-v4-1-flash",
    reasoning_effort="low",
    messages=[{"role": "user", "content": "Explain recursion in one sentence."}],
)

print(completion.choices[0].message.content)
print(completion.usage.completion_tokens_details.reasoning_tokens)

reasoning_effort es un argumento normal. Sus type hints incluyen none desde openai 2.8.0 y max desde 2.45.0, así que las versiones anteriores todavía envían esos valores, pero tu verificador de tipos se quejará. El texto del razonamiento en sí está en completion.choices[0].message.reasoning_content. No es parte de los tipos del SDK, pero el SDK conserva campos adicionales, así que el atributo funciona.

SDK de OpenAI para TypeScript

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.cheapaimodel.ai/v1",
  apiKey: process.env.CHEAPAIMODEL_API_KEY,
});

const completion = await client.chat.completions.create({
  model: "deepseek-v4-1-flash",
  reasoning_effort: "max",
  messages: [{ role: "user", content: "Explain recursion in one sentence." }],
});

'none' y 'max' pasan la verificación de tipos desde openai 6.46.0. reasoning_content tampoco está en los tipos del SDK, así que para leerlo, convierte el mensaje al tipo ChatCompletionMessage del SDK intersectado con { reasoning_content?: string }.

API de Responses

La API de Responses toma los mismos cuatro valores dentro de un objeto reasoning:

response = client.responses.create(
    model="deepseek-v4-1-flash",
    reasoning={"effort": "low"},
    input="Explain recursion in one sentence.",
)

print(response.output_text)
print(response.usage.output_tokens_details.reasoning_tokens)

Con "effort": "none", la respuesta no tiene elemento de razonamiento y reasoning_tokens es 0.

Desactivar el razonamiento

Hay dos interruptores. reasoning_effort: "none" es el portátil. DeepSeek también tiene su propio objeto thinking, que el SDK de Python de OpenAI envía a través de extra_body:

completion = client.chat.completions.create(
    model="deepseek-v4-1-flash",
    messages=[{"role": "user", "content": "..."}],
    extra_body={"thinking": {"type": "disabled"}},
)

En el SDK de TypeScript, thinking no está en los tipos. Agrégalo con un comentario // @ts-expect-error, que es lo que sugiere el README del SDK para parámetros no documentados. No uses la opción body por solicitud para esto: reemplaza todo el cuerpo de la solicitud en lugar de agregar un campo.

Usa un interruptor u el otro. Cuando enviamos ambos, thinking ganó en ambos sentidos: disabled con high no razonó, y enabled con none sí.

En frameworks

Apuntamos cada biblioteca a un servidor local que registra solicitudes y revisamos el cuerpo que realmente enviaba. Cada una puede enviar el campo, pero varias tienen un valor predeterminado que no lo hace.

LangChain (Python)

import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="deepseek-v4-1-flash",
    base_url="https://api.cheapaimodel.ai/v1",
    api_key=os.environ["CHEAPAIMODEL_API_KEY"],
    reasoning_effort="low",
)

llm.invoke("Explain recursion in one sentence.", reasoning_effort="max")  # per call

• Envía thinking con extra_body={"thinking": {...}}. Ponerlo en model_kwargs genera un TypeError.
• Pasar reasoning={"effort": ...} en lugar de reasoning_effort cambia ChatOpenAI silenciosamente a la API de Responses.
• ChatOpenAI descarta reasoning_content. El conteo de tokens sobrevive en usage_metadata["output_token_details"]["reasoning"]. Si necesitas el texto, ChatDeepSeek desde langchain-deepseek lo devuelve en additional_kwargs["reasoning_content"].

LlamaIndex

import os
from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    model="deepseek-v4-1-flash",
    api_base="https://api.cheapaimodel.ai/v1",
    api_key=os.environ["CHEAPAIMODEL_API_KEY"],
    is_chat_model=True,
    additional_kwargs={"reasoning_effort": "low"},
)

• Usa additional_kwargs. El constructor también tiene un argumento reasoning_effort=, pero solo se envía para los propios modelos de razonamiento de OpenAI, así que con V4.1 Flash no hace nada silenciosamente. También rechaza "max".
• thinking baja un nivel: additional_kwargs={"extra_body": {"thinking": {...}}}.

Vercel AI SDK

import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
import { generateText } from "ai";

const cheapaimodel = createOpenAICompatible({
  name: "cheapaimodel",
  baseURL: "https://api.cheapaimodel.ai/v1",
  apiKey: process.env.CHEAPAIMODEL_API_KEY,
});

const { text, reasoningText } = await generateText({
  model: cheapaimodel("deepseek-v4-1-flash"),
  prompt: "Explain recursion in one sentence.",
  providerOptions: { cheapaimodel: { reasoningEffort: "low" } },
});

• La clave bajo providerOptions es el name que le diste al proveedor. Escribe reasoningEffort en camelCase: reasoning_effort ahí se descarta silenciosamente.
• AI SDK 7 también tiene una opción reasoning: "low" de nivel superior que envía el mismo campo.
• thinking funciona bajo la misma clave: providerOptions: { cheapaimodel: { thinking: { type: "disabled" } } }.

LiteLLM

import os
import litellm

response = litellm.completion(
    model="openai/deepseek-v4-1-flash",
    api_base="https://api.cheapaimodel.ai/v1",
    api_key=os.environ["CHEAPAIMODEL_API_KEY"],
    reasoning_effort="low",
    messages=[{"role": "user", "content": "Explain recursion in one sentence."}],
)

• Conserva el prefijo openai/. Con deepseek/, LiteLLM convierte el esfuerzo en el interruptor de encendido/apagado de DeepSeek y descarta el nivel, así que low y max se convierten en un simple "razonamiento activado".
• En LiteLLM Proxy, configura reasoning_effort bajo el litellm_params del modelo. Un valor que envíe el cliente lo anula.

En herramientas y apps de programación

La mayoría de las herramientas solo envían el campo si se lo indicas. Si una herramienta no envía nada, DeepSeek se ejecuta en high.

Herramienta	Dónde configurarlo	Niveles a los que puedes llegar
Codex CLI	model_reasoning_effort en config.toml	los cuatro
Continue	requestOptions.extraBodyProperties en el modelo	los cuatro
Aider	--reasoning-effort, después de declarar la configuración (abajo)	los cuatro
Open WebUI	Model → Advanced Params → Reasoning Effort, configurado en Custom	los cuatro
Zed	reasoning_effort en el modelo en available_models	los cuatro
OpenClaw	la configuración compat del modelo (abajo)	los cuatro
n8n	OpenAI Chat Model → Options → Extra Body	los cuatro
Cline	Reasoning Effort en la configuración de OpenAI Compatible, o --thinking	none, low, high
Dify	Reasoning effort, después de configurar Thinking Mode Support (abajo)	none, low, high
Cursor	no disponible con una Base URL personalizada	solo el predeterminado

Probado con Codex CLI 0.163.0, Continue CLI 1.5.47, Aider 0.86.2, Cline CLI 3.0.71 y OpenClaw 2026.10.4; leído desde el código fuente para Open WebUI 0.12.2, Zed 1.24.2, el plugin compatible con la API de OpenAI de Dify 0.0.68 y n8n 2.43.6.

Codex CLI solo se comunica con proveedores personalizados a través de la Responses API, así que envía reasoning.effort. También configura model_reasoning_summary = "none". De lo contrario, Codex agrega reasoning.summary, que V4.1 Flash en cheapaimodel rechaza con un 400.

model_reasoning_effort = "low"
model_reasoning_summary = "none"

Si dejas model_reasoning_effort sin configurar, el banner de Codex dice "reasoning effort: none", pero no envía ningún esfuerzo, así que el modelo se ejecuta en high.

Continue no tiene opción de esfuerzo para modelos compatibles con OpenAI, pero agrega cualquier campo del cuerpo que incluyas:

models:
  - name: DeepSeek V4.1 Flash
    provider: openai
    model: deepseek-v4-1-flash
    apiBase: https://api.cheapaimodel.ai/v1
    apiKey: YOUR_API_KEY
    requestOptions:
      extraBodyProperties:
        reasoning_effort: low

Aider ignora --reasoning-effort para los modelos que no conoce e imprime una advertencia. Declara la configuración en .aider.model.settings.yml:

- name: openai/deepseek-v4-1-flash
  accepts_settings: ["reasoning_effort"]

Luego ejecuta aider --model openai/deepseek-v4-1-flash --reasoning-effort low, o escribe /reasoning-effort low en el chat. No pongas el campo directamente en extra_params: Aider lo descarta ahí.

OpenClaw trata cualquier Base URL personalizada como un proxy y no envía un esfuerzo a menos que la entrada del modelo indique que puede hacerlo. Agrega estos campos a la entrada de nuestra guía de OpenClaw:

{
  id: "deepseek-v4-1-flash",
  // ...the rest of the entry
  reasoning: true,
  compat: {
    supportsUsageInStreaming: true,
    supportsReasoningEffort: true,
    supportedReasoningEfforts: ["none", "low", "high", "max"],
  },
}

Luego configura un valor predeterminado en agents.defaults.models["cheapaimodel/deepseek-v4-1-flash"].params.thinking, por ejemplo "high". Sin él, las sesiones nuevas comienzan en low, y OpenClaw redondea hacia abajo los niveles que no tiene listados, así que medium se convierte en low.

n8n solo muestra su opción integrada Reasoning Effort para nombres de modelos de OpenAI. Usa Extra Body en su lugar, y haz coincidir el campo con la API que usa el nodo. Con Use Responses API activado, el valor predeterminado, escribe {"reasoning": {"effort": "low"}}. Con él desactivado, escribe {"reasoning_effort": "low"}.

Dify es el que hay que vigilar. Con el modo predeterminado Thinking Mode Support, "Only Non-Thinking Mode", Dify no envía ningún esfuerzo y solo oculta el razonamiento de la respuesta. El modelo sigue razonando en high, y de todos modos pagas por esos tokens. Para desactivar el razonamiento de verdad, elige un modo que incluya thinking y configura Reasoning effort en none.

Cursor no envía un esfuerzo para los modelos detrás de una Base URL personalizada, así que se ejecutan en high.

En otros endpoints compatibles con OpenAI

Todo lo anterior aplica a cualquier proveedor que sirva V4.1 Flash detrás de una Base URL compatible con OpenAI. Lo que varía es lo que el endpoint hace con el campo. Antes de confiar en él:

1. Verifica que llegue. Envía el mismo prompt con none y con max. Con none, reasoning_tokens debe ser 0 y el mensaje no debe tener reasoning_content. Si ambas solicitudes regresan iguales, el endpoint está descartando el campo y estás obteniendo su valor predeterminado.
2. Revisa la lista de modelos. Algunas pasarelas exponen cada nivel como su propio ID de modelo, por ejemplo con un sufijo -max o -none. Si la tuya lo hace, usa esos IDs. cheapaimodel tiene un solo ID, deepseek-v4-1-flash, y el campo decide.
3. Revisa qué pasa con un error de escritura. En cheapaimodel, "reasoning_effort": "turbo" devuelve 400 con "code": "InvalidParameter", así que un error falla de forma evidente. Un endpoint que descarta los valores que no reconoce se ejecutará silenciosamente con el valor predeterminado.
4. Quédate con none, low, high y max. La API de DeepSeek también acepta minimal, medium y xhigh de OpenAI y los asigna al nivel más cercano, pero no todos los endpoints los asignan de la misma manera. En nuestras pruebas, minimal se comportó más como high que como low.
5. No asumas que las reglas aplican igual en todos lados. Los proveedores que sirven el mismo modelo difieren en los detalles. La documentación de DeepSeek dice que su API devuelve 400 para tool_choice: "required" en modo de razonamiento y para conversaciones con herramientas que descartan reasoning_content. En cheapaimodel, ambas solicitudes pasaron en nuestras pruebas. Escribe tu código para que funcione bajo las reglas más estrictas.

Tres cosas que suelen causar problemas

max_tokens incluye el razonamiento

Con reasoning_effort: "high" y max_tokens: 100, obtuvimos finish_reason: "length" y un content vacío. Los 100 tokens se fueron al razonamiento. Si limitas la salida, deja espacio para esto. Cuando no configuras max_tokens, la API de DeepSeek usa 64K de forma predeterminada en modo de razonamiento y 128K en max.

Conserva reasoning_content en las conversaciones con herramientas

Cuando el modelo llama a una herramienta, su mensaje lleva reasoning_content junto con tool_calls. La API de DeepSeek requiere que lo envíes de vuelta, sin cambios, en cada solicitud posterior de esa conversación. En el SDK de Python de OpenAI, agregar el objeto de mensaje devuelto hace eso:

messages.append(completion.choices[0].message)

Las bibliotecas difieren en este punto. Los SDK de OpenAI, LiteLLM con el prefijo openai/ y el SDK de Vercel AI conservan reasoning_content cuando envías de vuelta el mensaje devuelto. ChatOpenAI y ChatDeepSeek de LangChain y OpenAILike de LlamaIndex lo omiten en la siguiente solicitud. En cheapaimodel, omitirlo no causó un error en nuestra prueba, pero en un endpoint que aplica la regla de DeepSeek, la solicitud falla con un 400.

En conversaciones sin herramientas, no necesitas enviarlo de vuelta. DeepSeek lo ignora.

La temperatura no dirige el razonamiento

En modo de razonamiento, temperature no tiene efecto, y un top_p menor a 0.95 se trata como 0.95. Para que las respuestas sean más rápidas o más cuidadosas, cambia el nivel de esfuerzo.

Verificarlo en cheapaimodel

Abre Registros en la consola y haz clic en una solicitud. Si enviaste reasoning_effort, los detalles lo muestran en Reasoning effort. Si la fila no está ahí, la solicitud se ejecutó con el valor predeterminado, high.

Los precios y los límites de contexto están en la página del modelo DeepSeek V4.1 Flash. Para obtener una clave y hacer tu primera llamada, consulta el Inicio rápido. La referencia propia de DeepSeek es su guía del modo de razonamiento.