DeepSeek-V3

DeepSeek V3

671B parameters, 37B active per token, 163,840-token context. Released 26 December 2024.

Technical report · The architecture every later DeepSeek generation is built on.

The Training Run Is the Story

Most model cards report what a model scores. This one is more interesting for what it reports about how it was made.

2.788 million H800 GPU hours for the complete training process, of which 2.664 million went to pre-training on 14.8 trillion tokens.

No irrecoverable loss spikes. No rollbacks. Stated plainly in the technical report.

That second line is the one worth pausing on. Training runs at this scale routinely diverge — the loss jumps, the run is abandoned, engineers restore a checkpoint from hours earlier and try again. Each rollback costs compute that produced nothing. A 671-billion-parameter run completing without one is a claim about engineering discipline more than about model architecture, and it is why the cost figure is as low as it is.

Three Techniques That Became Standard

Each solves a specific problem, and each has appeared in later models across the industry.

Auxiliary-loss-free load balancing

Mixture-of-Experts models must keep their experts evenly used. Left alone, routing collapses — a handful of experts absorb most tokens and the rest sit idle, wasting capacity.

The conventional fix adds an auxiliary loss term penalising imbalance. It works, and it costs quality: you are now optimising for two things, and the second one is not the task.

This model achieves balance without that term — and therefore without the penalty. That is the pioneering contribution, and the reason the technique propagated.

Multi-token prediction

Trained to predict more than one token ahead, which the report validates as improving model quality rather than merely accelerating inference.

It does both. The trained MTP module — 14B parameters, shipped alongside the 671B main model — also serves as a draft model for speculative decoding.

That is why the download is 685B rather than 671B: the extra 14B is the prediction module, and it is usable at inference rather than discarded after training.

FP8 mixed-precision training

The first validated demonstration that FP8 training works at extremely large scale.

Doing it required co-designing algorithms, framework, and hardware together, and overcoming the communication bottleneck in cross-node MoE training — the report describes reaching near-complete overlap of computation and communication, which is what turns a distributed training run from latency-bound into compute-bound.

The practical consequence for anyone self-hosting: because FP8 was native to training, only FP8 weights are published. BF16 is available through a conversion script, not as a download.

Multi-head Latent Attention

The attention mechanism, carried forward from the previous generation and validated at this scale.

MLA compresses the key-value cache into a latent representation rather than storing it in full. That single change is what makes a model this size affordable to serve at long context, and every subsequent DeepSeek generation builds on it — the sparse attention work in later releases sits on top of MLA rather than replacing it.

Architecture

Total download size is 685B: 671B main model plus 14B MTP module.

Specifications

The two licences are not the same. Code is MIT. Weights carry DeepSeek's own model licence, which permits commercial use subject to conditions. Read it against your deployment rather than assuming MIT terms extend to the weights — this is the only model in the DeepSeek line in this catalogue where that distinction applies.

Capabilities

It Answers Directly

Worth stating explicitly, because this catalogue is now mostly reasoning models.

There is no thinking mode, no effort parameter, no reasoning_content field to read or replay. The model receives a prompt and produces an answer.

Post-training did distil reasoning behaviour into it — verification and reflection patterns appear in its answers — but they arrive inside the response rather than as a separate trace.

Two practical consequences.

max_tokens covers the answer alone. No hidden budget consumption, no truncation mid-reasoning. A ceiling sized for the output you expect is a ceiling that works.

Latency depends on input and output length, not on how hard the model judged the question. For an interactive path, that consistency is frequently worth more than depth.

Where It Was Strong

Comprehensive evaluation placed it ahead of other open models of its time and comparable to leading closed models — in mathematics, knowledge, and code generation particularly.

The shape worth knowing before choosing it: knowledge, mathematics, and open-ended generation are its strengths. Competitive programming and repository-scale agentic engineering are not. Those axes are exactly what later releases in this line rebuilt, which tells you where the gap was.

If your workload is document analysis, general assistance, code generation from a specification, or mathematics, this model is a serious choice. If it is a multi-hour agent loop across a repository, it is not what this generation was built for.

Using DeepSeek V3 on DEVUP AI

Base URL: https://api.devupai.com/v1 · Model ID: deepseek-ai/DeepSeek-V3

First request — cURL

curl https://api.devupai.com/v1/chat/completions \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-ai/DeepSeek-V3",
    "messages": [
      {
        "role": "user",
        "content": "Write a Python function that merges overlapping date ranges, handling ranges that touch at an endpoint as distinct rather than overlapping. Include the edge cases in docstring examples."
      }
    ],
    "temperature": 0.7,
    "max_tokens": 4096
  }'

Sizing the ceiling honestly — Python

On a model with no reasoning pass, the output budget means what it says.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

reply = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.7,
    max_tokens=2048,  # the whole budget goes to the answer
)

print(reply.choices[0].message.content)
print(f"used {reply.usage.completion_tokens} of 2048")

Carry this habit into reasoning models with care. There, the same ceiling would be shared with a trace, and 2,048 tokens could produce nothing at all.

Extraction at low temperature — Python

import json
import re

reply = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3",
    messages=[
        {
            "role": "system",
            "content": (
                "Extract these fields as a single JSON object: order_id, issue_type, "
                "missing_items, contact. Use null for anything the message does not state. "
                "Reply with JSON only."
            ),
        },
        {"role": "user", "content": ticket},
    ],
    temperature=0.2,
    max_tokens=1024,
)

raw = reply.choices[0].message.content
cleaned = re.sub(r"^```(?:json)?|```$", "", raw, flags=re.MULTILINE).strip()

try:
    data = json.loads(cleaned)
except json.JSONDecodeError as exc:
    raise ValueError(f"model did not return parseable JSON: {cleaned[:400]}") from exc

Lowering the temperature for extraction is not decoration. The 0.7 default suits open-ended generation; a task with one correct answer does not benefit from variance, and every degree of it is a chance to produce a differently-shaped object your parser was not written for.

Long-document work — Python

from pathlib import Path

contract = Path("supplier_agreement.txt").read_text(encoding="utf-8")

reply = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3",
    messages=[
        {
            "role": "system",
            "content": (
                "Work only from the document supplied. Quote the clause behind every statement. "
                "Where the document does not address something you would expect it to, name the "
                "gap instead of filling it."
            ),
        },
        {"role": "user", "content": f"{contract}\n\nWhat are our obligations if the vendor is acquired?"},
    ],
    temperature=0.3,
    max_tokens=8192,
)

The 163,840-token window holds a substantial contract or a codebase section comfortably. It does not hold a document archive — that is where later models in this line went, and it is the clearest reason to move up.

Tool calling — Python

import json

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "lookup_order",
            "description": "Return order status, line items, and delivery events for an order ID.",
            "parameters": {
                "type": "object",
                "properties": {"order_id": {"type": "string"}},
                "required": ["order_id"],
            },
        },
    },
]


def lookup_order(order_id: str) -> dict:
    """Replace with your real data access layer."""
    raise NotImplementedError


HANDLERS = {"lookup_order": lookup_order}

thread = [{"role": "user", "content": "Why is order 48213 showing as incomplete?"}]

CEILING = 10

for step in range(CEILING):
    reply = client.chat.completions.create(
        model="deepseek-ai/DeepSeek-V3",
        messages=thread,
        tools=TOOLS,
        temperature=0.7,
        max_tokens=4096,
    )

    message = reply.choices[0].message
    thread.append(message)

    if not message.tool_calls:
        print(message.content)
        break

    for call in message.tool_calls:
        handler = HANDLERS.get(call.function.name)
        if handler is None:
            outcome = {"error": "unknown tool", "name": call.function.name}
        else:
            try:
                outcome = handler(**json.loads(call.function.arguments or "{}"))
            except Exception as exc:
                outcome = {"error": type(exc).__name__, "detail": str(exc)}

        thread.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(outcome)})
else:
    print(f"Stopped at the {CEILING}-step ceiling.")

Validate tool-call arguments against your schema before dispatching them. Tool calling on this generation predates the post-training work that later releases in this line invested in agent behaviour — treat a malformed argument as an expected case rather than an exceptional one.

The step ceiling is deliberately tighter than you would give a later model. This generation was not built for long autonomous loops, and a short leash reflects that honestly.

Node.js — DEVUP AI SDK

npm install devupai

import DevupAI from "devupai";

const client = new DevupAI({
  apiKey: process.env.DEVUP_API_KEY,
});

const reply = await client.chat.completions.create({
  model: "deepseek-ai/DeepSeek-V3",
  messages: [
    {
      role: "system",
      content:
        "Review this function. Report only defects that would produce a wrong result, " +
        "each with the input that triggers it.",
    },
    { role: "user", content: sourceCode },
  ],
  temperature: 0.3,
  max_tokens: 4096,
});

console.log(reply.choices[0]?.message?.content);

Streaming

stream = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3",
    messages=[{"role": "user", "content": "Explain why an auxiliary loss for expert balancing costs model quality."}],
    temperature=0.7,
    max_tokens=4096,
    stream=True,
)

for chunk in stream:
    if not chunk.choices:
        if getattr(chunk, "usage", None):
            print(f"\n\nin {chunk.usage.prompt_tokens:,} · out {chunk.usage.completion_tokens:,}")
        continue

    piece = chunk.choices[0].delta
    if getattr(piece, "content", None):
        print(piece.content, end="", flush=True)

Output begins immediately — there is no deliberation phase to wait through. That is what keeps this generation usable in interactive interfaces where a reasoning model feels stalled.

Recommended Generation Parameters

Self-Hosting Notes

Relevant if you are running it yourself rather than through an API.

FP8 weights only. FP8 training was native, so those are the published weights. A conversion script produces BF16 if you need it for experimentation.

Broad runtime support. The reference implementation ships a lightweight FP8 and BF16 demo, and the model is supported across the major serving frameworks in both precisions. AMD GPUs are supported through one of them in both FP8 and BF16, and Huawei Ascend devices are supported as well — unusually wide hardware coverage for a model of this size.

The MTP module is optional. It ships with the weights and enables speculative decoding, but the main model runs without it.

Practical Notes

Lower the temperature for anything with one correct answer.

Size max_tokens to the answer — there is no trace consuming it here.

Validate tool-call arguments before dispatch. This generation predates the agent-focused post-training that followed it.

Use the 163,840-token window with confidence; it holds well across its length.

Read the weights licence before commercial deployment. It is not the MIT licence that covers the code.

Parse structured output defensively and raise rather than defaulting on failure.

Limitations

Text only. No image, audio, or video input, and no image generation.

No reasoning trace. If your application needs visible intermediate reasoning, this generation does not produce one.

Agentic and competitive-coding results are modest relative to later models in the same line, and those are precisely the axes subsequent releases rebuilt.

Weights are not MIT-licensed. Commercial use is permitted under DeepSeek's own model licence, with conditions that should be read rather than assumed.

Only FP8 weights are published. BF16 requires conversion.

163,840-token context. Ample for documents, a fraction of what later releases in this family reach.

Tool calling predates the agent-focused post-training that followed. Validate arguments rather than trusting them.

Answers arrive confidently. With no visible reasoning, there is less signal about where the model was uncertain — ground factual work and require citations where correctness matters.