Cara mengatur reasoning effort DeepSeek V4.1 Flash di API apa pun yang kompatibel dengan OpenAI

DeepSeek V4.1 Flash berpikir dulu sebelum menjawab. Kalau kamu tidak bilang lain, model ini berpikir pada tingkat usaha high. Kamu bisa mengubahnya dengan satu field di permintaan, reasoning_effort. Ini field biasa di body permintaan, jadi kamu bisa mengaturnya per permintaan lewat endpoint mana pun yang meneruskannya, termasuk milik kami. Kamu tidak perlu model ID yang berbeda.

Postingan ini membahas empat levelnya, berapa biaya masing-masing dalam tes yang kami jalankan pada 16 Oktober 2026, cara mengatur field ini dari kode dan dari tools umum, dan cara memeriksa bahwa endpoint pihak ketiga benar-benar meneruskannya.

Versi singkat

Tambahkan reasoning_effort di samping 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: ..."}]
  }'

Nilai	Fungsinya
none	Mematikan reasoning. Model langsung menjawab.
low	Reasoning singkat. DeepSeek menyarankannya untuk tugas sederhana.
high	Default. DeepSeek menyarankannya untuk kerja agent sehari-hari.
max	Reasoning paling panjang, untuk masalah yang lebih sulit.

Kalau field ini tidak diisi, sama saja dengan mengirim high.

Berapa biaya tiap level

Kami mengirim satu soal matematika dengan satu jawaban benar ke https://api.cheapaimodel.ai/v1: berapa banyak pasangan terurut (a, b) bilangan bulat positif, keduanya maksimal 100, yang membuat a² + b² habis dibagi 13? (Jawabannya 1,491.) Tiap level dijalankan 8 kali, kecuali none, yang dijalankan 3 kali. Semua permintaan non-streaming.

Usaha	Rata-rata token reasoning	Rentang	Rata-rata waktu	Benar
none	0	0	14.0 s	0 dari 3
low	2,348	925–3,719	17.2 s	7 dari 8
high	3,081	2,232–3,629	20.4 s	8 dari 8
max	3,530	2,700–5,803	23.2 s	7 dari 8

Token reasoning ditagih sebagai token output. Pada harga V4.1 Flash kami saat tes dijalankan, $0.84 per juta token output, rata-rata permintaan berbiaya sekitar $0.002 di low dan $0.003 di max.

Yang menonjol:

• Dengan reasoning mati, model salah setiap kali. Dua kali ia mengabaikan "jawab hanya dengan angkanya" dan mengerjakan soal itu di jawaban yang terlihat, yang memakan waktu hampir sama dengan reasoning.
• high dan max hampir sama pada soal ini. max hanya sekali menghabiskan jelas lebih banyak, saat ia memilih berpikir jauh lebih lama (run 5,803 token).
• low memakai sekitar seperempat token lebih sedikit daripada high dan meleset sekali.

Satu soal bukan benchmark. Sebelum memilih default, jalankan sampel prompt kamu sendiri di dua level dan bandingkan usage.completion_tokens_details.reasoning_tokens dan jawabannya.

Mengaturnya dari kode

OpenAI Python SDK

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 adalah argumen biasa. Type hint-nya mencakup none dari openai 2.8.0 dan max dari 2.45.0, jadi versi lama tetap mengirim nilai itu tapi type checker kamu akan protes. Teks reasoning-nya sendiri ada di completion.choices[0].message.reasoning_content. Itu bukan bagian dari tipe SDK, tapi SDK menyimpan field tambahan, jadi atributnya berfungsi.

OpenAI TypeScript SDK

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' dan 'max' lolos type-check dari openai 6.46.0. reasoning_content juga bukan bagian dari tipe SDK, jadi untuk membacanya, cast pesan itu ke tipe ChatCompletionMessage milik SDK yang di-intersect dengan { reasoning_content?: string }.

Responses API

Responses API menerima empat nilai yang sama di dalam objek 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)

Dengan "effort": "none", responsnya tidak punya item reasoning dan reasoning_tokens bernilai 0.

Mematikan reasoning

Ada dua switch. reasoning_effort: "none" adalah yang portabel. DeepSeek juga punya objek thinking sendiri, yang dikirim oleh OpenAI Python SDK lewat extra_body:

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

Di TypeScript SDK, thinking tidak ada di tipe. Tambahkan dengan komentar // @ts-expect-error, seperti yang disarankan README SDK untuk parameter yang tidak terdokumentasi. Jangan pakai opsi body per permintaan untuk ini: opsi itu mengganti seluruh body permintaan, bukan menambahkan field.

Pakai salah satu switch saja. Saat kami kirim keduanya, thinking menang di kedua arah: disabled dengan high tidak reasoning, dan enabled dengan none malah reasoning.

Di framework

Kami arahkan tiap library ke server lokal yang mencatat permintaan, lalu periksa body yang benar-benar dikirim. Semuanya bisa mengirim field itu, tapi beberapa punya default yang tidak mengirim.

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

• Kirim thinking dengan extra_body={"thinking": {...}}. Kalau ditaruh di model_kwargs, muncul error TypeError.
• Mengirim reasoning={"effort": ...} alih-alih reasoning_effort diam-diam mengalihkan ChatOpenAI ke Responses API.
• ChatOpenAI membuang reasoning_content. Jumlah token tetap ada di usage_metadata["output_token_details"]["reasoning"]. Kalau kamu butuh teksnya, ChatDeepSeek dari langchain-deepseek mengembalikannya di 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"},
)

• Pakai additional_kwargs. Constructor-nya juga punya argumen reasoning_effort=, tapi itu hanya dikirim untuk model reasoning milik OpenAI sendiri, jadi dengan V4.1 Flash tidak berpengaruh apa-apa. Argumen itu juga menolak "max".
• thinking turun satu level: 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" } },
});

• Key di bawah providerOptions adalah name yang kamu berikan ke penyedia. Tulis reasoningEffort dalam camelCase: reasoning_effort di sana akan diam-diam dibuang.
• AI SDK 7 juga punya opsi reasoning: "low" di level teratas yang mengirim field yang sama.
• thinking berfungsi di bawah key yang sama: 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."}],
)

• Pertahankan awalan openai/. Dengan deepseek/, LiteLLM mengubah effort jadi switch on/off milik DeepSeek dan membuang levelnya, jadi low dan max sama-sama jadi "thinking on" biasa.
• Di LiteLLM Proxy, set reasoning_effort di bawah litellm_params milik model. Nilai yang dikirim klien akan menimpanya.

Di alat coding dan aplikasi

Sebagian besar alat hanya mengirim field itu kalau kamu suruh. Kalau alat tidak mengirim apa-apa, DeepSeek berjalan di high.

Alat	Di mana mengaturnya	Level yang bisa dicapai
Codex CLI	model_reasoning_effort di config.toml	keempatnya
Continue	requestOptions.extraBodyProperties di model	keempatnya
Aider	--reasoning-effort, setelah mendeklarasikan setting-nya (di bawah)	keempatnya
Open WebUI	Model → Advanced Params → Reasoning Effort, set ke Custom	keempatnya
Zed	reasoning_effort di model dalam available_models	keempatnya
OpenClaw	pengaturan compat milik model (di bawah)	keempatnya
n8n	OpenAI Chat Model → Options → Extra Body	keempatnya
Cline	Reasoning Effort di pengaturan OpenAI Compatible, atau --thinking	none, low, high
Dify	Reasoning effort, setelah mengatur Thinking Mode Support (di bawah)	none, low, high
Cursor	tidak tersedia dengan Base URL kustom	default saja

Diuji dengan Codex CLI 0.163.0, Continue CLI 1.5.47, Aider 0.86.2, Cline CLI 3.0.71, dan OpenClaw 2026.10.4; dibaca dari source untuk Open WebUI 0.12.2, Zed 1.24.2, plugin Dify yang kompatibel dengan OpenAI API 0.0.68, dan n8n 2.43.6.

Codex CLI cuma bisa terhubung ke penyedia kustom lewat Responses API, jadi dia mengirim reasoning.effort. Set juga model_reasoning_summary = "none". Kalau tidak, Codex menambahkan reasoning.summary, yang ditolak V4.1 Flash di cheapaimodel dengan 400.

model_reasoning_effort = "low"
model_reasoning_summary = "none"

Kalau kamu biarkan model_reasoning_effort kosong, banner Codex bilang "reasoning effort: none", tapi dia tidak mengirim effort sama sekali, jadi model berjalan di high.

Continue tidak punya opsi effort untuk model yang kompatibel dengan OpenAI, tapi dia menambahkan field body apa pun yang kamu daftarkan:

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 mengabaikan --reasoning-effort untuk model yang tidak dikenalnya dan menampilkan peringatan. Deklarasikan pengaturan itu di .aider.model.settings.yml:

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

Lalu jalankan aider --model openai/deepseek-v4-1-flash --reasoning-effort low, atau ketik /reasoning-effort low di chat. Jangan taruh field itu langsung di extra_params: Aider menghapusnya di sana.

OpenClaw menganggap semua Base URL kustom sebagai proxy dan tidak mengirim effort kecuali entri model menyatakan bisa. Tambahkan field ini ke entri dari panduan OpenClaw kami:

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

Lalu set default di agents.defaults.models["cheapaimodel/deepseek-v4-1-flash"].params.thinking, misalnya "high". Tanpanya, sesi baru mulai di low, dan OpenClaw membulatkan level yang tidak terdaftar ke bawah, jadi medium menjadi low.

n8n hanya menampilkan opsi Reasoning Effort bawaannya untuk nama model OpenAI. Pakai Extra Body saja, dan sesuaikan field dengan API yang dipakai node. Kalau Use Responses API aktif, yang merupakan default, tulis {"reasoning": {"effort": "low"}}. Kalau nonaktif, tulis {"reasoning_effort": "low"}.

Dify ini yang perlu diwaspadai. Dengan Thinking Mode Support bawaan, "Only Non-Thinking Mode", Dify tidak mengirim effort dan hanya menyembunyikan reasoning dari balasan. Model tetap bernalar di high, dan kamu tetap membayar token itu. Untuk benar-benar mematikan reasoning, pilih mode yang menyertakan thinking dan set Reasoning effort ke none.

Cursor tidak mengirim effort untuk model di balik Base URL kustom, jadi model berjalan di high.

Di endpoint lain yang kompatibel dengan OpenAI

Semua di atas berlaku untuk penyedia mana pun yang menyajikan V4.1 Flash di balik Base URL yang kompatibel dengan OpenAI. Yang berbeda adalah apa yang dilakukan endpoint dengan field itu. Sebelum kamu mengandalkannya:

1. Pastikan sampai. Kirim prompt yang sama dengan none dan dengan max. Dengan none, reasoning_tokens harus 0 dan pesannya tidak boleh punya reasoning_content. Kalau kedua permintaan balik dengan hasil yang sama, endpoint-nya membuang field itu dan kamu dapat nilai default-nya.
2. Cek daftar model. Sebagian gateway menampilkan tiap level sebagai model ID sendiri, misalnya dengan akhiran -max atau -none. Kalau punyamu begitu, pakai ID tersebut. cheapaimodel punya satu ID, deepseek-v4-1-flash, dan field-nya yang menentukan.
3. Cek apa yang terjadi kalau ada typo. Di cheapaimodel, "reasoning_effort": "turbo" mengembalikan 400 dengan "code": "InvalidParameter", jadi kesalahan langsung ketahuan. Endpoint yang membuang nilai yang tidak dikenali akan diam-diam jalan dengan default.
4. Pakai none, low, high, dan max saja. API DeepSeek sendiri juga menerima minimal, medium, dan xhigh milik OpenAI dan memetakannya ke level terdekat, tapi tiap endpoint tidak memetakannya dengan cara yang sama. Di pengujian kami, minimal lebih mirip high daripada low.
5. Jangan anggap aturannya sama di mana-mana. Penyedia yang menyajikan model yang sama bisa beda detailnya. Dokumentasi DeepSeek menyebut API-nya mengembalikan 400 untuk tool_choice: "required" di thinking mode dan untuk percakapan tool yang membuang reasoning_content. Di cheapaimodel, kedua permintaan itu berhasil di pengujian kami. Tulis kode kamu supaya jalan di aturan yang lebih ketat.

Tiga hal yang sering bikin orang keliru

max_tokens termasuk reasoning

Dengan reasoning_effort: "high" dan max_tokens: 100, kami dapat finish_reason: "length" dan content yang kosong. Semua 100 token habis untuk reasoning. Kalau kamu batasi output, sisakan ruang untuk itu. Kalau kamu tidak set max_tokens, API DeepSeek default-nya 64K di thinking mode dan 128K di max.

Simpan reasoning_content di percakapan tool

Saat model memanggil tool, pesannya membawa reasoning_content bersama tool_calls. API DeepSeek mengharuskan kamu mengirimnya balik, tanpa diubah, di setiap permintaan berikutnya dalam percakapan itu. Di OpenAI Python SDK, menambahkan objek pesan yang dikembalikan akan melakukannya:

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

Library bisa beda di sini. SDK OpenAI, LiteLLM dengan prefix openai/, dan Vercel AI SDK menyimpan reasoning_content saat kamu mengirim balik pesan yang dikembalikan. ChatOpenAI dan ChatDeepSeek milik LangChain serta OpenAILike milik LlamaIndex tidak menyertakannya di permintaan berikutnya. Di cheapaimodel, tidak menyertakannya tidak menyebabkan error di pengujian kami, tapi di endpoint yang menegakkan aturan DeepSeek, permintaannya gagal dengan 400.

Di percakapan tanpa tool, kamu tidak perlu mengirimnya balik. DeepSeek mengabaikannya.

Temperature tidak mengarahkan reasoning

Di thinking mode, temperature tidak berpengaruh, dan top_p di bawah 0.95 diperlakukan sebagai 0.95. Supaya jawaban lebih cepat atau lebih teliti, ubah level effort-nya saja.

Cek di cheapaimodel

Buka Log di Konsol dan klik salah satu permintaan. Kalau kamu mengirim reasoning_effort, detailnya menampilkan itu di Reasoning effort. Kalau barisnya tidak ada, permintaan itu jalan dengan default, high.

Harga dan batas konteks ada di halaman model DeepSeek V4.1 Flash. Untuk dapat key dan melakukan panggilan pertamamu, lihat Mulai cepat. Referensi DeepSeek sendiri ada di panduan thinking mode.