Qwen3-1.7B

Qwen3-1.7B

A compact 1.7B chat model that switches between a thinking mode for reasoning and a quick mode for dialogue. Suits developers who want a small open model for chat, translation and agent features.

Made by Qwen on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Qwen3-1.7B is a compact chat model from Qwen with about 1.7 billion parameters, built on Qwen3-1.7B-Base. One model covers two modes. Thinking mode works through math, logic and code step by step, and non-thinking mode gives quick replies for everyday dialogue.

Who it suits: Developers who want a small open model that runs on ordinary hardware, and people building chat, translation or agent features that need to stay light. It also suits learners who want to see how a thinking switch works.

Industry | Who uses it | How they use it | Example
Software | App developers | Run a small chat model inside an app | Add a local assistant to a tool
Developer tools | Agent builders | Let the model call external tools | Connect it to an API endpoint through vLLM
Education | Students and teachers | Study reasoning with the thinking switch | Compare answers with thinking on and off
Localization | Multilingual teams | Translate and follow instructions in many languages | Draft short translations for review

Anyone who needs the strongest answers on hard problems can skip it, since larger Qwen3 models exist.

Where to use it:

• Python scripts that use the transformers library on Windows, macOS or Linux
• SGLang and vLLM, which serve it as an OpenAI-compatible API endpoint
• Ollama and llama.cpp for running it locally
• LMStudio, MLX-LM and KTransformers, which have added Qwen3 support too

Use case | Who | What they get back
Local chat assistant | Developers | Replies generated on your own machine
Step by step reasoning | Students and developers | A thinking section followed by the final answer
Tool-using agents | Agent builders | Calls to external tools in both modes
Translation | Multilingual users | Text in more than 100 languages and dialects

How to set it up:

• Python with pip
• A recent transformers version, since versions below 4.51.0 fail with a KeyError
• Memory for the weights, about 4.1 GB in BF16 or about 1 GB at 4-bit (an estimate)

1. Install the Hugging Face hub package.
2. Download the model files.
3. Update transformers, then load the model with the snippet below.

pip install -U huggingface_hub
hf download Qwen/Qwen3-1.7B

How to use it: Load the tokenizer and model, build a chat message, and let the model generate. The enable_thinking flag switches between thinking and non-thinking mode. The code then splits the thinking text from the final answer by finding the end-of-thinking token.

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "Qwen/Qwen3-1.7B"

# 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,
    enable_thinking=True # Switches between thinking and non-thinking modes. Default is True.
)
model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

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

# parsing thinking content
try:
    # rindex finding 151668 (</think>)
    index = len(output_ids) - output_ids[::-1].index(151668)
except ValueError:
    index = 0

thinking_content = tokenizer.decode(output_ids[:index], skip_special_tokens=True).strip("\n")
content = tokenizer.decode(output_ids[index:], skip_special_tokens=True).strip("\n")

print("thinking content:", thinking_content)
print("content:", content)

To serve it as an API endpoint, use SGLang 0.4.6.post1 or newer, or vLLM 0.8.5 or newer.

python -m sglang.launch_server --model-path Qwen/Qwen3-1.7B --reasoning-parser qwen3

vllm serve Qwen/Qwen3-1.7B --enable-reasoning --reasoning-parser deepseek_r1

Tool | What it does
transformers | Loads the model and runs generation in Python
SGLang | Serves the model as an OpenAI-compatible endpoint with a reasoning parser
vLLM | Serves the model as an OpenAI-compatible endpoint with a reasoning parser
enable_thinking | Switches between thinking and non-thinking mode

Example: You replace the prompt with "Explain what a hash map is in two sentences." and run the snippet. It prints two parts. First comes the thinking content, then the final content that holds the two-sentence explanation.

For newcomers and experts: If you are new, download the files, run the snippet as it is, and read both printed parts. Then set enable_thinking to False and compare how the reply changes.

Experts get a causal language model with 28 layers, 16 query heads and 8 key-value heads (GQA), about 1.4B non-embedding parameters and a 32,768 token context. If you see endless repetition, the card advises its recommended sampling settings and a presence_penalty of 1.5.

You build a chat message
The template sets thinking on or off
The model generates tokens
The code splits thinking from the answer

Good to know:

• Context: 32,768 tokens
• Repetition: set presence_penalty to 1.5 if the output repeats endlessly
• License: Apache 2.0
• Cost to run: none named, no API key or account, only hardware with enough memory
• Data it reaches: it downloads model files from Hugging Face, then generates on your own machine
• Not for: the source names no forbidden uses, and a model this small is a weak fit for the hardest tasks

On Hugging Face, 13 November 2026

• Task: text generation
• Library: transformers
• Parameters: 2B
• Weights: about 4.1 GB in BF16; about 1 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 3,203,490
• Likes: 618
• License: apache-2.0
• Based on: Qwen/Qwen3-1.7B-Base
• Quantized versions: 497
• Fine-tunes: 1,399
• Tags: transformers, safetensors, qwen3, text-generation, conversational

Links

• Model: https://huggingface.co/Qwen/Qwen3-1.7B
• Files: https://huggingface.co/Qwen/Qwen3-1.7B/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download Qwen/Qwen3-1.7B

Then follow the usage in its model card. Nothing in this kit runs by itself.