DeepSeek R1

DeepSeek R1 is DeepSeek’s flagship open-weight reasoning model, designed for advanced multi-step logical reasoning, mathematical problem solving, and structured code generation. Unlike standard chat-oriented language models, DeepSeek R1 is optimized to produce intermediate reasoning steps before delivering a final answer, making it particularly suited for complex analytical tasks.

As part of the broader DeepSeek model ecosystem, DeepSeek R1 builds on the DeepSeek-V3 architecture and introduces a reasoning-focused training pipeline that combines supervised fine-tuning with reinforcement learning. The model is released with open weights, allowing researchers and developers to download and run it locally, while also being accessible through the official DeepSeek API via the reasoning endpoint.

What Is DeepSeek R1 and How Does It Work?

DeepSeek R1 is the flagship first-generation reasoning model from DeepSeek, designed for advanced multi-step reasoning tasks. It was introduced alongside an experimental precursor called R1-Zero as part of DeepSeek’s effort to incentivize chain-of-thought reasoning in large language models. Unlike R1-Zero (which we discuss below), DeepSeek R1 incorporates a “cold-start” supervised training stage before reinforcement learning (RL) in its training pipeline. This means some curated examples were used to initially fine-tune the model, and then large-scale RL was applied – an approach that significantly improved the model’s coherence and reliability.

According to DeepSeek’s published benchmark evaluations, DeepSeek R1 achieved results described by the authors as comparable to OpenAI’s o1 on selected reasoning and coding tasks, while mitigating several of the instability issues observed in the earlier RL-only variant.

DeepSeek R1 builds upon the DeepSeek-V3 architecture and adopts a Mixture-of-Experts (MoE) design. As reported in the official model documentation, the system contains approximately 671 billion total parameters, with around 37 billion parameters activated per token during inference, alongside support for a 128K token context window. The model is released under the MIT License, enabling broad research and commercial use in accordance with the license terms.

DeepSeek R1 Architecture Overview

DeepSeek R1 is built on the DeepSeek-V3 base architecture and uses a Mixture-of-Experts (MoE) design rather than a fully dense transformer model. Understanding this architecture helps explain both the model’s scale and its efficiency.

Mixture-of-Experts (MoE) Explained

In a traditional dense language model, every parameter participates in processing every token. In contrast, a Mixture-of-Experts architecture activates only a subset of parameters for each token during inference.

DeepSeek R1 reportedly contains approximately 671 billion total parameters, but only around 37 billion parameters are active per token. This means that while the full model is extremely large in total capacity, the computational cost per token is significantly lower than if all 671B parameters were used simultaneously.

The model achieves this through a routing mechanism that selects specific expert subnetworks (“experts”) to process each token. Different tokens may activate different experts depending on the context and reasoning needs.

671B Total vs 37B Active Parameters

The distinction between total parameters and active parameters is critical:

• Total parameters (~671B): Represents the full set of expert weights stored in the model.
• Active parameters (~37B per token): The subset actually used during a single forward pass.

This design allows DeepSeek R1 to combine:

• Very high representational capacity
• More efficient per-token computation compared to an equivalently sized dense model

In practical terms, the model can maintain large-scale reasoning capabilities without requiring all parameters to be active simultaneously.

Why MoE Matters for Reasoning Models

For reasoning-focused systems like DeepSeek R1, capacity and specialization are important. MoE architectures allow:

• Specialized expert subnetworks to focus on different patterns (e.g., mathematics, logic, language structure).
• Greater scaling potential without linear growth in compute cost.
• Improved efficiency in long-context reasoning tasks.

Because DeepSeek R1 also supports a 128K token context window, combining extended context with MoE scaling enables the model to process complex, multi-step problems that require tracking large amounts of information.

How DeepSeek R1 Differs from Dense Models

Dense models (such as many earlier GPT-style systems) use all parameters for every token. While this approach is straightforward, scaling dense models increases inference cost proportionally.

DeepSeek R1’s MoE design differs in several ways:

This architectural difference helps explain how DeepSeek R1 can maintain extremely high total parameter capacity while keeping per-token activation closer to a ~37B-scale model.

DeepSeek R1 vs R1-Zero vs R1 Distill Models

DeepSeek’s “R1” model family includes multiple variants tailored to different needs. The core variants are the initial DeepSeek-R1-Zero, the improved DeepSeek-R1, and a set of DeepSeek-R1-Distill models. The table below summarizes their differences:

DeepSeek-R1-Zero

DeepSeek-R1-Zero is the initial experiment in the R1 family, trained via large-scale reinforcement learning only, with no supervised fine-tuning step upfront. This RL-only approach allowed the base model to “explore” reasoning behaviors autonomously – R1-Zero was observed to develop powerful capabilities like self-verification of answers, reflective thinking, and extremely long chain-of-thought (CoT) reasoning sequences. In fact, R1-Zero was a milestone:

DeepSeek-R1-Zero demonstrated that large-scale reinforcement learning alone can substantially enhance reasoning behaviors in language models, according to DeepSeek’s research findings. However, the absence of an initial supervised fine-tuning stage resulted in output instability in some cases.

As documented by the DeepSeek team, R1-Zero occasionally produced excessively long reasoning traces, repetitive loops, or less coherent responses. While valuable as a research experiment exploring pure reinforcement learning approaches, R1-Zero is generally described in the official materials as a precursor to DeepSeek-R1, which was introduced to improve alignment, readability, and practical usability.

DeepSeek-R1

DeepSeek-R1 (often just called “R1”) is the refined version of R1-Zero, introduced to overcome the shortcomings of the RL-only approach. The DeepSeek team implemented a more complex training pipeline with multiple stages: specifically, they added two supervised fine-tuning (SFT) stages (one before and one after RL) in addition to two RL stages. In simple terms, the model was first “seeded” with some high-quality reasoning data (the cold-start phase) to give it a foundation in coherent reasoning and general capabilities. Then, it underwent RL to discover improved reasoning patterns, followed by alignment fine-tuning to steer its outputs to be user-friendly, and possibly a final RL for preference optimization.

This hybrid training strategy produced a model that retained R1-Zero’s strong multi-step reasoning capabilities while improving output stability and readability. According to DeepSeek’s technical report, DeepSeek-R1 addresses several of the alignment and coherence issues observed in R1-Zero, resulting in more structured and user-friendly reasoning outputs.

In published benchmark results, the DeepSeek team reports that R1 achieved performance comparable to OpenAI’s o1 on selected mathematics, coding, and reasoning evaluations. Based on these reported results, DeepSeek-R1 became the primary recommended model within the R1 family. Both DeepSeek-R1 and R1-Zero have been released as open-weight models, but for most practical use cases, DeepSeek-R1 is presented in the official documentation as the preferred option due to its improved alignment and stability.

DeepSeek R1 Distill Models

DeepSeek also provides a series of DeepSeek-R1-Distill models, which are distilled (compressed) versions of R1’s reasoning knowledge into smaller, more manageable model sizes. In this context, distillation means using the large R1 model to generate a large set of reasoning examples (questions with step-by-step answers) and then fine-tuning smaller models on that data.

The idea is to transfer the “reasoning patterns” discovered by the huge R1 into models that are easier to run. The team demonstrated that a well-distilled smaller model can actually outperform a small model trained with RL from scratch – in other words, piggybacking on R1’s solutions is a very effective way to teach a smaller model to reason.

Official R1-Distill variants: Six distilled checkpoints have been released, leveraging popular open-source base models. These include four Qwen 2.5-based models (approximately 1.5B, 7B, 14B, and 32B parameters each) and two Llama 3-based models (around 8B and 70B parameters). All were fine-tuned on about 800k sample solutions generated by DeepSeek-R1. The largest distilled models (for example, DeepSeek-R1-Distill-Qwen-32B and the 70B Llama variant) achieve stronger benchmark performance for their size.

According to DeepSeek’s published benchmark results, the 32B Qwen distilled model outperformed OpenAI’s o1-mini on selected internal evaluations, achieving competitive results among open dense models of similar scale.

While these distilled models do not quite reach the full 671B R1’s absolute performance, they are much more accessible for users without supercomputer-level hardware. You can use them in similar ways as you would use the underlying Qwen or Llama models, with the benefit of R1’s reasoning prowess baked in. It’s worth noting that each distilled model carries the license of its base model – for example, the Qwen-based distills inherit Qwen’s Apache 2.0 license, and the Llama-based ones use the Llama 3 license.

(We’ll discuss licensing more later, but in practice this means you should double-check each model’s usage terms on its model card.) Overall, the R1-Distill family provides flexible options: you get a spectrum of model sizes (from ~1.5B up to 70B parameters) that trade off raw power for efficiency, all trained to mimic DeepSeek-R1’s way of reasoning.

DeepSeek-R1-0528 (What the Update Introduced)

DeepSeek-R1-0528 refers to a version update of the DeepSeek R1 model, released on May 28, 2025 (the “0528” suffix reflects the release date). According to DeepSeek’s official documentation, this update introduced additional post-training optimization and increased computational refinement aimed at improving reasoning depth and overall inference quality.

In published benchmark results, DeepSeek reports that R1-0528 achieved higher scores than the earlier R1 version across several reasoning-focused evaluations. For example, on AIME-style mathematical competition benchmarks, reported accuracy increased from 70% in the previous release to 87.5% in R1-0528. The improvement is attributed to longer and more structured reasoning traces, with the model reportedly using significantly more intermediate reasoning tokens per question compared to the earlier version.

DeepSeek also indicates that R1-0528 shows stronger results across selected mathematics, programming, and logic benchmarks relative to the initial R1 release. While benchmark methodologies and evaluation setups vary, the updated model demonstrates measurable gains within DeepSeek’s published evaluation framework.

Beyond benchmark accuracy improvements, DeepSeek’s official release notes describe qualitative enhancements in reasoning depth, factual reliability, and improved support for structured outputs and tool usage.

The R1-0528 update introduced official support for JSON-formatted outputs and function calling within reasoning mode, making the model more suitable for developer-oriented workflows that require structured responses or tool integration. While DeepSeek indicates improvements in factual reliability compared to earlier versions, specific hallucination metrics may vary depending on evaluation methodology and task setup.

In the DeepSeek chat interface, the team also mentioned enhanced front-end capabilities and a smoother experience for coding-related interactions. Importantly, no changes to the API interface were required; R1-0528 replaced the previous R1 version under the hood, allowing existing applications using the reasoning endpoint to continue functioning without modification.

In summary, DeepSeek-R1-0528 represents a refinement of DeepSeek R1 that focuses on deeper reasoning, improved reliability, and stronger structured output support, while remaining fully open-weight and aligned with the original model’s licensing terms.

How to Use DeepSeek R1 (Official Options)

There are two primary ways to use DeepSeek R1 officially: through the DeepSeek API (or web interface), or by using the open-source model weights locally. We’ll outline both methods below.

Use via DeepSeek API (Reasoning Endpoint)

The DeepSeek API provides hosted access to R1 via a cloud endpoint, and it is designed to be compatible with the OpenAI API format. This means you can call DeepSeek’s models with the same API calls you might use for OpenAI’s chat models – just pointing to DeepSeek’s base URL and using a DeepSeek API key. In the API, DeepSeek R1 is exposed as the “thinking mode” model, distinct from DeepSeek’s standard chat model.

Specifically, to invoke R1 through the API, you set the model name to "deepseek-reasoner" in your API request. (By contrast, the normal non-reasoning model is called "deepseek-chat" – that one corresponds to the DeepSeek-V3 series without the chain-of-thought.) Using the deepseek-reasoner model triggers the R1’s reasoning behavior: the model will produce an internal reasoning trace and a final answer.

When you call the API’s chat completion endpoint with model: "deepseek-reasoner", the response structure actually includes two parts from the model: a reasoning_content (the chain-of-thought it generated) and the content (the final answer). This allows your application to capture the model’s intermediate thinking if desired.

In multi-turn conversations, the DeepSeek API expects you to handle these appropriately (typically, you pass only the final answers as the assistant’s messages to the next turn, not the raw reasoning text). The official documentation provides examples on how to parse and use these fields. If you enable streaming, tokens for reasoning_content and content will stream separately so you can even show the model “thinking” in real time.

For end-users who don’t want to code against the API, DeepSeek also offers a web chat interface. On DeepSeek’s official chat site, you can switch on a toggle called “DeepThink” to engage the R1 reasoning mode. With DeepThink enabled, the model will display its step-by-step thought process before the final answer (in the UI, the chain-of-thought might appear in a special format or collapsible section). Under the hood, this is the same as using deepseek-reasoner – it’s just an easy way to experience the reasoning output interactively.

API vs open model naming: It’s worth clarifying that the open-source checkpoint is named DeepSeek-R1 (or DeepSeek-R1-0528 for the updated version) on platforms like Hugging Face, but in the API you do not literally request "DeepSeek-R1" by that name. Instead, the DeepSeek platform uses the deepseek-reasoner identifier to route your request to the latest R1 model. So, if you see references to “DeepSeek R1” in documentation, remember that on the API level the model is invoked via the reasoning endpoint name.

Other than that naming difference, the model’s behavior is the same. Also note that as of the latest update, tool usage and JSON output are supported in the reasoning API – to use those, you include the appropriate fields in your API call (for example, a tools array and an extra_body: {"thinking": {"type": "enabled"}} parameter as shown in the official guides). These options allow R1 to perform function calls during its chain-of-thought when using the API.

In summary, using DeepSeek R1 via the official API is straightforward: get an API key, then specify model=deepseek-reasoner in your requests. You’ll benefit from DeepSeek’s hosted infrastructure (no need to run the huge model yourself) and can obtain both the reasoning trace and final answers. For more details on integrating the API, see the DeepSeek API documentation pages.

Use Open Weights (Hugging Face)

One of the distinguishing features of DeepSeek R1 is that it is released as an open-weight model, meaning you can download the model files and run it on your own hardware. The official DeepSeek-AI profile on Hugging Face hosts all the R1-family checkpoints (including R1, R1-0528, R1-Zero, and the distilled models). Using the open weights gives you full control – you’re not reliant on an external service and you can experiment freely with the model. However, there are some important considerations given the scale and format of these models.

Running the full R1 (37B active parameters, MoE architecture): DeepSeek-R1 and R1-Zero are enormous models – effectively 37 billion parameter Transformer models with MoE (Mixture-of-Experts) that in total reference ~671 billion parameters (though only a subset is active at any time). These models also have an extremely long context length (128k tokens), which is an order of magnitude larger than typical LLMs. As a result, standard off-the-shelf tooling may not support them out of the box. In fact, the model’s Hugging Face card explicitly notes that Hugging Face’s Transformers library is not yet directly supported for R1 inference. This is likely due to the custom architecture and huge memory requirements.

To run DeepSeek R1 locally, you will need very high-end hardware (for example, multiple GPUs with large memory, or a TPU pod) and possibly specialized software that can handle MoE and sharded models. DeepSeek’s team points users to their GitHub repository (the DeepSeek-V3 repo) for more information on how to deploy R1 in a research environment. Indeed, their backend implementation uses custom optimizations (there are references to LightLLM and other internal solutions in the codebase) to make inference feasible. If you are not an expert in distributed model deployment, running the full 671B model yourself is non-trivial – keep that in mind.

Running distilled models: In contrast, the DeepSeek-R1-Distill models are much easier to work with. These distilled models use conventional architectures (either Qwen or Llama variants) and have sizes ranging from 1.5B to 70B parameters, which many existing tools can handle. According to the model card, the distill models “can be utilized in the same manner as Qwen or Llama models”.

This means you should be able to load them with Hugging Face Transformers or other common frameworks, often without modifications (you might need to pass trust_remote_code=True for certain Qwen variants or use the provided configuration, since DeepSeek mentions they slightly adjusted some configs/tokenizers). The context length for these will typically match their base models (for example, some Qwen-based ones support 8K or more if the base was extended; Llama 3 base might be 4K). Always check the individual model card for any special instructions.

DeepSeek’s documentation even gives quick-start examples for the distilled models using third-party inference libraries. For instance, they show a one-line launch with vLLM (a high-performance inference engine) to serve the 32B Qwen distilled model, and another example using SGLang (a serving framework). These are not DeepSeek’s own tools but are recommended ways to get the model running efficiently.

You could also use other community solutions: for example, you might load a smaller distill model on CPU using a library like llama.cpp (if you quantize it to fit in RAM), or deploy on GPU with text-generation-webui, etc. Such approaches are outside official documentation, so proceed as appropriate – the key point is that the distilled models make local use feasible for enthusiasts and developers without supercomputers.

Usage tips: If you run R1 (full or distill) locally, keep in mind the usage recommendations provided by DeepSeek. They suggest using a moderate temperature (around 0.6) to avoid incoherent rambling, not using a system prompt (instead, put all instructions in the user prompt), and prompting the model to reason step-by-step (e.g. “Please reason step by step…”) especially for math problems. Additionally, because the model’s default behavior is to output its reasoning in <think>...</think> tags and then the answer, you may want to ensure it does so.

The authors note that sometimes the R1 models might skip the <think> section on certain queries, which can reduce performance; they recommend forcing the model’s reply to begin with a <think> tag to guarantee it goes into reasoning mode. This is a unique aspect of DeepSeek R1 – it has an explicit “thinking output” format. If you enforce that format (or simply always include a request like “show your reasoning”), you’ll get the full chain-of-thought, which is usually where R1 shines.

In summary, open-weight usage of DeepSeek R1 is powerful but comes in two flavors: use the full model only if you have the capability (and need the absolute best reasoning performance), otherwise leverage the distilled models for a far easier deployment. Either way, the model being open means you aren’t locked into any one platform – an advantage for long-term, independent use of DeepSeek R1.

DeepSeek R1 vs DeepSeek V3 (Quick Comparison)

Within the DeepSeek ecosystem, DeepSeek R1 and DeepSeek V3 serve different purposes. DeepSeek R1 is specifically optimized for multi-step reasoning, structured problem solving, and transparent chain-of-thought outputs. In contrast, DeepSeek V3 is designed as a general-purpose conversational model focused on faster responses and everyday chat tasks.

If your primary need is advanced reasoning — such as mathematical derivations, complex code logic, or multi-step analytical tasks — DeepSeek R1 is the intended model. For lightweight conversation or simple queries that do not require detailed reasoning traces, DeepSeek V3 may be more efficient.

Best Use Cases for DeepSeek R1

What kinds of tasks is DeepSeek R1 particularly well-suited for? Below are some of the top use cases that play to R1’s strengths as a reasoning-focused model:

• Multi-step Math Problem Solving: DeepSeek R1 excels at competition-level math questions, word problems, and proofs that require step-by-step derivations. It can lay out a chain of reasoning for complex calculations or geometry proofs, making it useful as a math problem solver or tutor (especially with its high accuracy on benchmarks like AIME).
• Algorithmic and Logical Puzzles: For logic puzzles, brainteasers, or algorithmic reasoning tasks (e.g. evaluating code logic, solving riddles, or performing stepwise deduction), R1’s chain-of-thought approach allows it to break the problem into parts and work through them systematically. This often leads to more reliable solutions on tasks where pure end-to-end models might get confused.
• Code Generation and Debugging (with reasoning): When writing code or pseudocode that requires reasoning about the solution (such as competitive programming challenges, debugging tricky issues, or multi-step code synthesis), R1 can be very effective. It not only writes code but also explains its logic as it goes, which is valuable for verifying the solution. Its performance on coding benchmarks (Codeforces, LiveCode, etc.) is among the best for open models, indicating it’s adept at handling complex coding tasks with reasoning.
• Long-Form Analytical Q&A: With a 128K context, R1 can ingest very large documents or multiple sources and perform in-depth analysis. Use it for tasks like reading a lengthy research paper or legal document and answering detailed questions about it, where it needs to analyze and reason across many context pages. The chain-of-thought helps ensure it keeps track of details and how it arrives at an answer.
• Multi-hop Knowledge Queries: For questions that require connecting disparate pieces of information (multi-hop QA across different domains or paragraphs), R1’s ability to do intermediate reasoning is useful. It will explicitly reason out which facts are needed from each source before concluding – reducing the chance of skipping a critical step. This makes it suitable as a researcher’s assistant or for tasks like medical or scientific Q&A where reasoning through evidence is important.
• Self-Verification Scenarios: In applications where getting a correct answer is critical, you can use R1’s tendency for self-verification. The model might double-check its own answers within the <think> process (a behavior noted in R1-Zero and retained in R1). For example, if used for calculations or data analysis, R1 might internally cross-verify results before presenting an answer. This makes it a good choice when you want the model to be cautious and thorough.
• Educational and Explanatory Chatbot: R1 can act as a tutor or explainer, solving problems step-by-step and teaching the user the reasoning. For instance, in an educational app, R1 could answer a student’s question by not just giving the answer, but also showing how to arrive at that answer. Its detailed reasoning capability is ideal for learning contexts.
• Tool-using Agent: With the new support for function calling and tool use, R1 can serve as the “brain” of an agent that needs to plan multi-step solutions and call external tools/APIs in between. For example, it can reason about a user request, decide to fetch data via a tool call (thanks to function calling support), then incorporate the result into its final answer. This ability to intermix reasoning and tool usage is great for complex tasks like data retrieval, calculations, or interacting with external systems in a controlled manner.

In all these cases, DeepSeek R1’s thinking mode and long context give it an edge over models that only produce a final answer. Whenever you need transparency in the model’s thought process or have a complicated problem that benefits from intermediate reasoning, R1 is a top choice.

When You Should Not Use DeepSeek R1

While R1 is powerful, it’s not the best fit for every scenario. Here are situations where you might avoid using DeepSeek R1 or choose a different model:

• When you need very fast or real-time responses: DeepSeek R1 is a large, heavy model that takes longer to generate answers (especially when producing long reasoning traces). If low latency is crucial (e.g. in a real-time chatbot with tight response limits or an interactive setting on a mobile device), a smaller model or a non-thinking mode might be preferable.
• Simple or one-step queries: If the task is straightforward – like a simple fact lookup, a short instruction, or casual chitchat – R1’s extensive reasoning is overkill. It may output unnecessary verbose thinking for a question that could be answered in one sentence. In such cases, a standard DeepSeek V3 chat model (non-reasoning) or any lightweight model can do the job more efficiently.
• Creative writing and open-ended generation: R1 is tuned for accuracy and logical reasoning, not for creative flair or conversational versatility. For tasks like storytelling, generating imaginative content, or having a free-flowing casual dialogue, R1’s style might seem a bit rigid or overly analytical. A model focused on creative writing or general chat (without the <think> structure) would likely be a better choice for those purposes.
• Scenarios with strict token limits or memory constraints: Running R1 (or even the larger distilled models) demands significant memory. If you only have a CPU or a single small GPU, loading the 37B active parameters (or even a 32B model) might be impossible or extremely slow. In deployment contexts with limited resources, you should not attempt to use R1 – opt for the smallest distill that meets your needs, or use DeepSeek’s API so the heavy lifting is on their side.
• When you don’t want chain-of-thought output: Some applications might not want the model to produce any intermediate reasoning text (for example, if you only care about a concise final answer for an end-user). While R1 can produce just an answer, its default behavior and advantage lie in showing its work. If that aspect is undesired or confusing to users, a non-reasoning model might be more straightforward. (You can disable thinking mode in the API by simply using the non-reasoner model, DeepSeek V3, instead.)
• Ultra-short context or memory tasks: If your inputs are always very short (say a one-sentence query) and you never need the 128k context, then you’re not leveraging one of R1’s key features but still incurring its cost. In such cases, a smaller model with a normal context window would be more practical.
• Frequent knowledge updates or domain-specific info: DeepSeek R1’s knowledge is fixed as of its training data (like most LLMs). If your use case requires up-to-the-minute information or very domain-specific knowledge that the model likely wasn’t trained on, you might need to integrate retrieval or use a specialized model. R1 can call tools (with the new update), but if not using that, a retrieval-augmented approach with a simpler model could be more efficient than relying on R1’s internal knowledge.

In summary, you should not use DeepSeek R1 when a lighter, faster model would suffice or when R1’s detailed reasoning adds no value (or even detracts from the user experience). Always match the tool to the task – R1 is best reserved for the hard reasoning problems rather than everyday quick responses.

Licensing and Availability Notes

DeepSeek R1 and its variants are offered under open-source licenses, but it’s important to understand the specifics to ensure compliant use. The DeepSeek-R1 model weights are released under the MIT License, as stated on the official Hugging Face model page. However, distilled variants inherit the licenses of their respective base models (Apache 2.0 for Qwen-based models and Llama license for Llama-based variants).

MIT is a very permissive license – it allows commercial use, redistribution, modifications, and the creation of derivative works. In fact, the DeepSeek team explicitly encourages the community to distill and commercialize freely using R1’s outputs. They even updated the license terms at launch to clarify that API outputs can be used for fine-tuning or distillation without restriction. This is great news for developers: you can integrate R1 into products or research projects without worrying about a non-commercial clause on the main model.

However, not all R1-family models share the same license, due to their different base models. The DeepSeek-R1-Distill models inherit licenses from the models they are based on. Here’s a breakdown of those: The four Qwen-based distilled models (1.5B, 7B, 14B, 32B) utilize bases from Tencent’s Qwen 2.5 series, which are under the Apache 2.0 License. Apache 2.0, like MIT, permits commercial use and modifications, so those variants remain very permissive. On the other hand, the two Llama-based distilled models (8B and 70B) use Meta’s Llama 3 series as bases.

The Llama 3 family comes with its own license agreements (at the time of release, Meta’s Llama models typically had a community-use license or similar, potentially allowing research and commercial use with some conditions). The exact license is referenced on their model cards – for example, “Llama3.3 license”. If you plan to use the Llama-derived R1 distills, be sure to consult those license terms; they may have clauses about usage or distribution that differ from MIT or Apache. In short, each R1 distill model should be treated according to its listed license. There isn’t a one-size-fits-all license for the whole family.

In terms of availability: All the model weights (R1, R1-0528, R1-Zero, and distills) are available on Hugging Face under the deepseek-ai organization. The official model cards provide the latest information, usage examples, and any model-specific quirks. The technical report for DeepSeek-R1 is published on arXiv (reference number arXiv:2501.12948) and linked in the model card – it’s a useful resource if you want to dive into the research details.

The DeepSeek team’s GitHub accounts (such as the DeepSeek-R1 and DeepSeek-V3 repositories) contain code and sometimes tools or scripts that can help with running the models. Finally, the DeepSeek Platform (for API access) and the chat.deepseek.com site (for interactive use) are the official channels to use R1 without hosting it yourself. All in all, DeepSeek has made R1 quite accessible: open weights, open code, and an open license for the main model. Just keep an eye on the specific licenses of distilled variants if you use those, and you’ll be on solid ground.

Frequently Asked Questions About DeepSeek R1