DeepSeek V3.1 is DeepSeek’s hybrid text model: the same named edition supports thinking and non-thinking responses through different chat-template settings. The producer highlights improved tool use, agent tasks and reasoning efficiency over its earlier model. It accepts written instructions and text context and generates an answer, code or tool-call content. The original V3.1 identity is separate from Terminus, V3.2 and the V4 family.
The model card lists 671 billion total parameters, 37 billion active parameters and a 128K context for both its base and post-trained editions. V3.1 builds on the original V3 base with extended training on long documents before post-training. Its mixture-of-experts and latent-attention structure follows the V3 architecture. These design facts explain the long-context text profile without turning the context figure into a separate maximum-output specification.
Non-thinking mode prepares a direct response, while thinking mode starts a reasoning phase before the answer. The producer template uses a closing thinking marker for direct replies and an opening thinking marker for the current reasoning turn. In a multi-turn conversation, earlier reasoning content is dropped while final replies and the closing marker remain in the context. This is the original V3.1 history rule, distinct from the later V3.2 rule that preserves reasoning across tool-related messages.
Standard tool calling is documented in non-thinking mode. The application supplies function names, descriptions and parameter schemas; the model returns a selected tool name and JSON arguments in the producer’s tool-call representation. The application executes the operation and returns its result. Give tools specific purposes and keep the returned observation linked to the call, so the next model step has evidence rather than an assumption that an action occurred.
Thinking-mode search uses a separate specialised search-agent format. DeepSeek documents a user-provided search tool for questions requiring external or current information, with repeated calls and observations over several turns. Search is therefore part of the surrounding workflow, not an assertion that a text response independently browsed the web. Define the question, the source criteria and the final answer you need before the search task starts.
For coding, supply the relevant fragment or files, observed behaviour, expected behaviour and constraints to preserve. An illustrative brief is: “Identify the cause of this failure for the supplied input, propose a focused correction and explain the condition that the change handles.” For a document task, label source sections and ask for a comparison against explicit requirements. Require the final answer to distinguish the source-supported conclusion from a proposed next action.
The producer trains V3.1 using the UE8M0 FP8 scale format for weights and activations. Its local recommendations also identify precision-sensitive parameters that must be handled correctly. These are characteristics of the published producer reference, not a claim about every application’s selected precision or implementation. A derivative, a quantized variant and the later Terminus checkpoint remain separate choices from the named original V3.1 edition.
Prepare longer work with a clear question, source labels and a defined final artifact. Budget conversation, source text, reasoning and output within the documented context and keep only relevant evidence as the task grows. For an agent, specify the allowed actions and the criterion that marks the result complete. The useful deliverable is a reviewable textual answer, code proposal or source-backed analysis tied to the input and the observations the application actually returned.
", "aboutText": "DeepSeek V3.1 is DeepSeek’s hybrid text model: the same named edition supports thinking and non-thinking responses through different chat-template settings. The producer highlights improved tool use, agent tasks and reasoning efficiency over its earlier model. It accepts written instructions and text context and generates an answer, code or tool-call content. The original V3.1 identity is separate from Terminus, V3.2 and the V4 family.\n\nThe model card lists 671 billion total parameters, 37 billion active parameters and a 128K context for both its base and post-trained editions. V3.1 builds on the original V3 base with extended training on long documents before post-training. Its mixture-of-experts and latent-attention structure follows the V3 architecture. These design facts explain the long-context text profile without turning the context figure into a separate maximum-output specification.\n\nNon-thinking mode prepares a direct response, while thinking mode starts a reasoning phase before the answer. The producer template uses a closing thinking marker for direct replies and an opening thinking marker for the current reasoning turn. In a multi-turn conversation, earlier reasoning content is dropped while final replies and the closing marker remain in the context. This is the original V3.1 history rule, distinct from the later V3.2 rule that preserves reasoning across tool-related messages.\n\nStandard tool calling is documented in non-thinking mode. The application supplies function names, descriptions and parameter schemas; the model returns a selected tool name and JSON arguments in the producer’s tool-call representation. The application executes the operation and returns its result. Give tools specific purposes and keep the returned observation linked to the call, so the next model step has evidence rather than an assumption that an action occurred.\n\nThinking-mode search uses a separate specialised search-agent format. DeepSeek documents a user-provided search tool for questions requiring external or current information, with repeated calls and observations over several turns. Search is therefore part of the surrounding workflow, not an assertion that a text response independently browsed the web. Define the question, the source criteria and the final answer you need before the search task starts.\n\nFor coding, supply the relevant fragment or files, observed behaviour, expected behaviour and constraints to preserve. An illustrative brief is: “Identify the cause of this failure for the supplied input, propose a focused correction and explain the condition that the change handles.” For a document task, label source sections and ask for a comparison against explicit requirements. Require the final answer to distinguish the source-supported conclusion from a proposed next action.\n\nThe producer trains V3.1 using the UE8M0 FP8 scale format for weights and activations. Its local recommendations also identify precision-sensitive parameters that must be handled correctly. These are characteristics of the published producer reference, not a claim about every application’s selected precision or implementation. A derivative, a quantized variant and the later Terminus checkpoint remain separate choices from the named original V3.1 edition.\n\nPrepare longer work with a clear question, source labels and a defined final artifact. Budget conversation, source text, reasoning and output within the documented context and keep only relevant evidence as the task grows. For an agent, specify the allowed actions and the criterion that marks the result complete. The useful deliverable is a reviewable textual answer, code proposal or source-backed analysis tied to the input and the observations the application actually returned.", "editorialOverlay": { "copy_fields": null, "copy_sha256": null, "copy_source": null, "html_sha256": "9228357b6dfb6c3f02b7ed14a4852c9c25707ccb2e8ac94ad17c8e37ba71085d", "module_sha256": "ee9dc1c50b1e6a8fb7fa062030fcb4646b9aaaeb08be513b723a5a92a7290f06", "raw_model_unchanged": true, "schema": "ailoot-native-model-editorial-v1" }, "locale": "en", "methods": [ { "html": "deepseek-v3.1-thinkingDeepSeek V3.1 is a hybrid text model with thinking and direct-response modes in one edition. Its 128K context and improved tool-use profile support coding, document analysis and application-supplied search, with text or proposed tool calls as the result.
This description covers the model’s capabilities. Available in Ailoot inputs, outputs and options are listed for the selected method below.
DeepSeek V3.1 is DeepSeek’s hybrid text model: the same named edition supports thinking and non-thinking responses through different chat-template settings. The producer highlights improved tool use, agent tasks and reasoning efficiency over its earlier model. It accepts written instructions and text context and generates an answer, code or tool-call content. The original V3.1 identity is separate from Terminus, V3.2 and the V4 family.
The model card lists 671 billion total parameters, 37 billion active parameters and a 128K context for both its base and post-trained editions. V3.1 builds on the original V3 base with extended training on long documents before post-training. Its mixture-of-experts and latent-attention structure follows the V3 architecture. These design facts explain the long-context text profile without turning the context figure into a separate maximum-output specification.
Non-thinking mode prepares a direct response, while thinking mode starts a reasoning phase before the answer. The producer template uses a closing thinking marker for direct replies and an opening thinking marker for the current reasoning turn. In a multi-turn conversation, earlier reasoning content is dropped while final replies and the closing marker remain in the context. This is the original V3.1 history rule, distinct from the later V3.2 rule that preserves reasoning across tool-related messages.
Standard tool calling is documented in non-thinking mode. The application supplies function names, descriptions and parameter schemas; the model returns a selected tool name and JSON arguments in the producer’s tool-call representation. The application executes the operation and returns its result. Give tools specific purposes and keep the returned observation linked to the call, so the next model step has evidence rather than an assumption that an action occurred.
Thinking-mode search uses a separate specialised search-agent format. DeepSeek documents a user-provided search tool for questions requiring external or current information, with repeated calls and observations over several turns. Search is therefore part of the surrounding workflow, not an assertion that a text response independently browsed the web. Define the question, the source criteria and the final answer you need before the search task starts.
For coding, supply the relevant fragment or files, observed behaviour, expected behaviour and constraints to preserve. An illustrative brief is: “Identify the cause of this failure for the supplied input, propose a focused correction and explain the condition that the change handles.” For a document task, label source sections and ask for a comparison against explicit requirements. Require the final answer to distinguish the source-supported conclusion from a proposed next action.
The producer trains V3.1 using the UE8M0 FP8 scale format for weights and activations. Its local recommendations also identify precision-sensitive parameters that must be handled correctly. These are characteristics of the published producer reference, not a claim about every application’s selected precision or implementation. A derivative, a quantized variant and the later Terminus checkpoint remain separate choices from the named original V3.1 edition.
Prepare longer work with a clear question, source labels and a defined final artifact. Budget conversation, source text, reasoning and output within the documented context and keep only relevant evidence as the task grows. For an agent, specify the allowed actions and the criterion that marks the result complete. The useful deliverable is a reviewable textual answer, code proposal or source-backed analysis tied to the input and the observations the application actually returned.
POST /v1/chat/completionstexttext| Field | Type | Requirement | Values & limits | Default |
|---|---|---|---|---|
Fieldmodel | Typestring | RequirementRequired | Values & limits deepseek-v3.1-thinking | Default— |
Fieldmessages | Typemessage[] | RequirementRequired | Values & limits Minimum items: 1 | Default— |
Fieldmessages[].role | Typestring | RequirementRequired | Values & limits Model-specific | Default— |
Fieldmessages[].content | Typestring | RequirementOptional | Values & limits Applies when: Text conversation | Default— |
Fieldstream | Typeboolean | RequirementOptional | Values & limits | Defaultfalse |
Text · UTF8 text
messages[].content
| Parameter | Contract |
|---|---|
Parametercontent_type | Contractapplication/json |
Parameterrequired | Contractmodel, messages |
Parametermaterial_types | Contracttext |
Parametermessages | Contractmessage array with role/content shape |
Parameterfile_material | Contractactual UTF-8 document inserted as literal text; no file ID inferred |
Parameteroptional_controls | Contractstream |
Parametercontrol_scope | ContractText conversation; stream is a boolean and defaults to false. |
Parameteroutput_modalities | Contracttext |
Parameterhosted_operations | Contractfalse |
Parametermultimodal_input_binding | Contractnull |
Method aliases: /chat/completions
Lifecycle: synchronous_or_streamed
Send exact model ID with messages.
Context length is not an output cap.
A text file may supply literal text; image/audio/file-object inputs need exact binding.
Tariff references do not add request options. Supported parameters are listed for the selected method.
| Configuration | Rate schedule | Charge |
|---|---|---|
| ConfigurationBase token rates | Rate scheduleBase rate | Charge Input · Input tokens $0.000572 / 1K tokens Output · Output tokens $0.0023 / 1K tokens Input · Cache read $0 / 1K tokens Input · Cache write $0 / 1K tokens Input · Cache write, 1 hour — / 1K tokens |
Ailoot reserves an estimated amount before a request. After the result, it settles the final charge from measured usage. Streaming settlement uses the final usage record. How reservation and settlement work →
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"model":"deepseek-v3.1-thinking","messages":[{"role":"user","content":"hello"}],"stream":false}')\n\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \\\n -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nr=json.loads(Path("result.json").read_text())\nfor x in r.get("choices",[]):\n if x.get("message",{}).get("content"): print(x["message"]["content"])\nPY_RESULT\nfrom openai import OpenAI\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nresult=client.chat.completions.create(model="deepseek-v3.1-thinking", messages=[{"role":"user","content":"hello"}], stream=False)\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n ext = "png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "jpg" if raw.startswith(b"\\xff\\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(result.to_dict(mode="json"))\njson or SSE
Keep every complete returned response, file and content part.
Keep every choice and its content/tool calls/reasoning. In SSE assemble deltas by choice/tool index, retain the final finish reason and usage.
Keep request/response IDs and headers. No generic text job retrieval URL is supplied.
| Field | Type |
|---|---|
Fieldchoices[].index | Typeinteger |
Fieldchoices[].message.content | Typestring|null |
Fieldchoices[].message.tool_calls | Typetool_call[] |
Fieldchoices[].message.reasoning_content | Typestring |
Fieldchoices[].message.reasoning_details | Typeobject|array |
Fieldchoices[].finish_reason | Typestring|null |
Fieldusage | Typeobject |
| Response | Condition | Next step |
|---|---|---|
Response400 · invalid_request_error | ConditionInvalid required fields, material representation or parameter value | Next stepCorrect the indicated fields before a new creation request. |
Ailoot Ultra deepseek-v3.1-thinking
/chat/completions