Model reference · open weights

Qwen3-2507

LLMs Qwen Text gen · MoE 7 builds Open weights 3.4M dl/mo

Qwen3-2507 is an open-weight language model from Qwen. Qwen3-4B-Instruct-2507-FP8 (FP8) weighs 5.2 GB; the smallest configuration that runs it is RTX 3060 12 GB.

  • Qwen3-4B-Instruct-2507 is a 4.0B parameter causal language model developed by Qwen for text generation tasks.
  • It features a native context length of 262,144 tokens and is designed for non-thinking mode operation.
  • The model is released under the Apache-2.0 license.

Summary of the Qwen/Qwen3-4B-Instruct-2507 model card, 2026-10-01. The estimate below is for another build of the family.

What it is

Released byQwen
Released2025-08-05
Parameters4.0B
VRAM5.2 GB for the weights

What it runs on

Memory and cards for Qwen3-4B-Instruct-2507-FP8 (FP8)

5.2 GBweights, file size
147 MBcache per 1K tokens
707 MBruntime overhead, at least
262,144 tokenscontext max
CardRequests at onceContext maxMemory
8K each32K each
RTX 3060 12 GB
FP8 without its speed-up here
4137K11.6 GB
RTX 4060 Ti 16 GB7163K15.4 GB
RTX 3090 24 GB
FP8 without its speed-up here
143115K23.4 GB
RTX 4090 24 GB143115K23.4 GB
RTX 5090 32 GB205166K31.0 GB
L40S 48 GB317252K44.0 GB
A100 80 GB
FP8 without its speed-up here
5914all 256K78.2 GB
H100 80 GB5614all 256K78.1 GB
RTX PRO 6000 Blackwell 96 GB6917all 256K93.8 GB
DGX Spark (GB10) 128 GB unified8020all 256K107 GB
H200 141 GB10526all 256K138 GB
B200 180 GB13734all 256K176 GB
2× RTX 3060 12 GB
tensor parallel · FP8 without its speed-up here
133110K11.6 GB a card
2× RTX 4060 Ti 16 GB
tensor parallel
205160K15.4 GB a card
Memory needed at each load
Requests at once8K tokens each32K tokens each
17.1 GB10.7 GB
511.9 GB30.1 GB
815.6 GB44.6 GB
1625.2 GB83.2 GB
3244.6 GB161 GB
6483.2 GB315 GB

One card, with vLLM's small-card settings.

Builds

Sizes, precisions & builds

BuildParamsPrecisionWeightsSmallest setup
Qwen3-4B-Instruct-2507 ↗ 4.0BBF16 8.0 GBRTX 3060 12 GB
Qwen3-4B-Instruct-2507-FP8 (above) ↗ 4.4BFP8 5.2 GBRTX 3060 12 GB
Qwen3-30B-A3B-Instruct-2507 ↗ 30.5BBF16 61.1 GBH100 80 GB
Qwen3-30B-A3B-Instruct-2507-FP8 ↗ 30.5BFP8 31.2 GBL40S 48 GB
Qwen3-235B-A22B-Instruct-2507-FP8 ↗ 235.1BFP8 236 GB2× H200 141 GB
Qwen3-235B-A22B-Instruct-2507 ↗ 235.1BBF16 470 GB4× H200 141 GB
Qwen3-4B-Instruct-2507-unsloth-bnb-4bit ↗
packaged by unsloth
4.1BINT4 3.5 GBRTX 3060 12 GB

From the model card

What Qwen says about Qwen3-2507

Read the model card

Highlights

We introduce the updated version of the Qwen3-4B non-thinking mode, named Qwen3-4B-Instruct-2507, featuring the following key enhancements:

  • Significant improvements in general capabilities, including instruction following, logical reasoning, text comprehension, mathematics, science, coding and tool usage.
  • Substantial gains in long-tail knowledge coverage across multiple languages.
  • Markedly better alignment with user preferences in subjective and open-ended tasks, enabling more helpful responses and higher-quality text generation.
  • Enhanced capabilities in 256K long-context understanding.

Model Overview

Qwen3-4B-Instruct-2507 has the following features:

  • Type: Causal Language Models
  • Training Stage: Pretraining & Post-training
  • Number of Parameters: 4.0B
  • Number of Paramaters (Non-Embedding): 3.6B
  • Number of Layers: 36
  • Number of Attention Heads (GQA): 32 for Q and 8 for KV
  • Context Length: 262,144 natively.

NOTE: This model supports only non-thinking mode and does not generate ```` blocks in its output. Meanwhile, specifying enable_thinking=False is no longer required.

For more details, including benchmark evaluation, hardware requirements, and inference performance, please refer to our blog, GitHub, and Documentation.

Performance

GPT-4.1-nano-2025-04-14Qwen3-30B-A3B Non-ThinkingQwen3-4B Non-ThinkingQwen3-4B-Instruct-2507
Knowledge
MMLU-Pro62.869.158.069.6
MMLU-Redux80.284.177.384.2
GPQA50.354.841.762.0
SuperGPQA32.242.232.042.8
Reasoning
AIME2522.721.619.147.4
HMMT259.712.012.131.0
ZebraLogic14.833.235.280.2
LiveBench 2024112541.559.448.463.0
Coding
LiveCodeBench v6 (25.02-25.05)31.529.026.435.1
MultiPL-E76.374.666.676.8
Aider-Polyglot9.824.413.812.9
Alignment
IFEval74.583.781.283.4
Arena-Hard v2*15.924.89.543.4
Creative Writing v372.768.153.683.5
WritingBench66.972.268.583.4
Agent
BFCL-v353.058.657.661.9
TAU1-Retail23.538.324.348.7
TAU1-Airline14.018.016.032.0
TAU2-Retail-31.628.140.4
TAU2-Airline-18.012.024.0
TAU2-Telecom-18.417.513.2
Multilingualism
MultiIF60.770.861.369.0
MMLU-ProX56.265.149.661.6
INCLUDE58.667.853.860.1
PolyMATH15.623.316.631.1

*: For reproducibility, we report the win rates evaluated by GPT-4.1.

Quickstart

The code of Qwen3 has been in the latest Hugging Face transformers and we advise you to use the latest version of transformers.

With transformers<4.51.0, you will encounter the following error:

KeyError: 'qwen3'

The following contains a code snippet illustrating how to use the model generate content based on given inputs.

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "Qwen/Qwen3-4B-Instruct-2507"

# load the tokenizer and the model
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto"
)

# prepare the model input
prompt = "Give me a short introduction to large language model."
messages = [
    {"role": "user", "content": prompt}
]
text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
)
model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

# conduct text completion
generated_ids = model.generate(
    **model_inputs,
    max_new_tokens=16384
)
output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist()

content = tokenizer.decode(output_ids, skip_special_tokens=True)

print("content:", content)

For deployment, you can use sglang>=0.4.6.post1 or vllm>=0.8.5 or to create an OpenAI-compatible API endpoint:

  • SGLang:
    python -m sglang.launch_server --model-path Qwen/Qwen3-4B-Instruct-2507 --context-length 262144
    
  • vLLM:
    vllm serve Qwen/Qwen3-4B-Instruct-2507 --max-model-len 262144
    

Note: If you encounter out-of-memory (OOM) issues, consider reducing the context length to a shorter value, such as 32,768.

For local use, applications such as Ollama, LMStudio, MLX-LM, llama.cpp, and KTransformers have also supported Qwen3.

Agentic Use

Qwen3 excels in tool calling capabilities. We recommend using Qwen-Agent to make the best use of agentic ability of Qwen3. Qwen-Agent encapsulates tool-calling templates and tool-calling parsers internally, greatly reducing coding complexity.

To define the available tools, you can use the MCP configuration file, use the integrated tool of Qwen-Agent, or integrate other tools by yourself.

from qwen_agent.agents import Assistant

# Define LLM
llm_cfg = {
    'model': 'Qwen3-4B-Instruct-2507',

    # Use a custom endpoint compatible with OpenAI API:
    'model_server': 'http://localhost:8000/v1',  # api_base
    'api_key': 'EMPTY',
}

# Define Tools
tools = [
    {'mcpServers': {  # You can specify the MCP configuration file
            'time': {
                'command': 'uvx',
                'args': ['mcp-server-time', '--local-timezone=Asia/Shanghai']
            },
            "fetch": {
                "command": "uvx",
                "args": ["mcp-server-fetch"]
            }
        }
    },
  'code_interpreter',  # Built-in tools
]

# Define

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms