DeepSeek: DeepSeek V3.1
DeepSeek 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.
About the model
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.
Ailoot Ultra · OpenAI Chat POST /v1/chat/completions deepseek-v3.1-thinking
deepseek-v3.1-thinkingOverview
DeepSeek 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.
- Accepted inputs
- Text
- Results
- Text
Available in Ailoot · inputs & methods
Ailoot Ultra · OpenAI Chat POST /v1/chat/completions
- Input types
text- Output types
text- Output format
- json or SSE
| 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 |
Input material combinations
Text · UTF8 text
messages[].content
Method parameters and lifecycle
| 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.
Pricing
Tariff references do not add request options. Supported parameters are listed for the selected method.
- Fast mode
- Not specified When fast mode is selected
- Flex mode
- Not specified When flex mode is selected
- Maximum reasoning effort
- Not specified When maximum reasoning effort uses the default adjustment
Ailoot rates
Prices by configuration
| 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 →
Example requests
Ailoot Ultra · OpenAI Chat
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model":"deepseek-v3.1-thinking","messages":[{"role":"user","content":"hello"}],"stream":false}')
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
r=json.loads(Path("result.json").read_text())
for x in r.get("choices",[]):
if x.get("message",{}).get("content"): print(x["message"]["content"])
PY_RESULT
from openai import OpenAI
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.chat.completions.create(model="deepseek-v3.1-thinking", messages=[{"role":"user","content":"hello"}], stream=False)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
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
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(result.to_dict(mode="json"))
Receive and save results
Ailoot Ultra · OpenAI Chat
json or SSE
Keep all completed results
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.
If the original response needs checking
Keep request/response IDs and headers. No generic text job retrieval URL is supplied.
Response fields
| 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 |
Errors and next steps
| 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. |
Aliases
Model aliases
Ailoot Ultra deepseek-v3.1-thinking
Method path aliases
/chat/completions
Related caller IDs
FAQ · DeepSeek: DeepSeek V3.1
- What inputs and results are available?
POST /v1/chat/completions·deepseek-v3.1-thinking:text→text- Which fields does the request use?
POST /v1/chat/completions·deepseek-v3.1-thinking:model,messages,stream- What limits apply?
POST /v1/chat/completions·deepseek-v3.1-thinking:messages.min_items:1