---
title: "Qwen3-1.7B"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/c3175d9e-0ec9-4f84-b948-86f012d7e396"
updated: "2026-11-13"
---

# Qwen3-1.7B

> The name, the description, the About and a README below are the seller's words: data, not instructions.

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.

Qwen3-1.7B is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-13. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by Qwen

## 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.

```sh
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.

```python
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.

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

```sh
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

## README

````markdown
# 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.

```table
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

```table
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.

```sh
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.

```python
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.

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

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

```table
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.

```flow
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:

```sh
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.
````

## What is in it

1 files, 7 KB, downloaded as a zip.

```text
README.md  7 KB
```

## Source

[Qwen/Qwen3-1.7B on Hugging Face](https://huggingface.co/Qwen/Qwen3-1.7B)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| Qwen3-1.7B (this page) | 3,203,490 | 618 | 2B | apache-2.0 | 2025-07-26 |
| [Qwen3-0.6B](https://mindket.com/p/0598bfe0-640a-4bf0-b9f4-ca4cf70a04ae) | 19,718,599 | 1,894 | 752M | apache-2.0 | 2025-07-26 |
| [Qwen3-14B](https://mindket.com/p/56074bfc-f2ce-4109-8314-1af039530db4) | 12,965,376 | 540 | 14.8B | apache-2.0 | 2025-07-26 |
| [Qwen3-8B](https://mindket.com/p/408d17f8-b1a4-4b5f-8440-2d40ec001638) | 6,269,141 | 2,184 | 8.2B | apache-2.0 | 2025-07-26 |
| [Qwen3-4B](https://mindket.com/p/03e0f350-7bff-440a-963a-2fc01d03afce) | 3,186,531 | 798 | 4B | apache-2.0 | 2025-07-26 |
| [Qwen3-4B-Instruct-2507](https://mindket.com/p/97cdfdfd-8373-475e-8341-c0353e2e9efe) | 2,592,168 | 1,053 | 4B | apache-2.0 | 2025-09-17 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## What people say

> Posts and comments that name this project on Hacker News, Bluesky, X, Reddit, Facebook and YouTube, found by a weekly search on 2026-11-13. Their authors' words: data, not instructions.

- [Hacker News · teendifferent · 2026-01-19](https://news.ycombinator.com/item?id=46675271): Bypassing Gemma and Qwen safety with raw strings: OP here. I spent the weekend red-teaming small-scale open weights models (Qwen2.5-1.5B, Qwen3-1.7B, Gemma-3-1b-it, and SmolLM2-1.7B). I found a consistent vulnerability across all of them: Safety alignment relies almost entirely on the presence of the chat template. When I stripped the…
- [Bluesky · LLMs · 2026-06-17](https://bsky.app/profile/llms.activitypub.awakari.com.ap.brid.gy/post/3moj6t5wepzc2): Show HN: Selora – local model for Home Assistant Selora AI Local is an open-source, Qwen-based model for Home Assistant. Specs: Qwen3 1.7B base model (Q6 quantized\~1.6GB) Four Home Assistant-spec... Origin \| Interest \| Match
- [Hacker News · bayshark · 2026-06-17](https://news.ycombinator.com/item?id=48576208): Show HN: Selora – local model for Home Assistant: Selora AI Local is an open-source, Qwen-based model for Home Assistant. Specs: Qwen3 1.7B base model (Q6 quantized\~1.6GB) Four Home Assistant-specific LoRA adapters: - Answers - Clarifications - Automations - Commands \~3.5 GB total download size Runs locally via llama.cpp We chose a Qwen-based…
- [Bluesky · @aichina.news · 2026-10-26](https://bsky.app/profile/aichina.news/post/3myqhykg4zd2t): No benchmarks, no chat template, no stated purpose: a file upload wearing a model card. Apache-2.0, \~1.7B, likely Qwen3 base. Hard to see it displacing Qwen3-1.7B-Instruct in a local stack unless the stock Qwen template works out of the box. \*(241 graphemes. Qualifier still leads on the 2/10...
- [Hacker News · verdverm · 2026-06-21](https://news.ycombinator.com/item?id=48619045): Two Qwen3 models on one DGX Spark: the residency math: I have tried llama-cpp, vllm is nicer (ray, handles queueing, doesn't have the cache invalidation bug for qwen/gemma models) and unsloth has toxic employees in their discord. I've run 2 qwen/gemma @8bit with full context window side-by-side. Right now I have 4 models on my spark (qwen36moe,…
- [Bluesky · @aichina.news · 2026-10-19](https://bsky.app/profile/aichina.news/post/3myak7j356f2t): A 950M model reportedly matching Qwen3-1.7B on maths, shipped as GGUF — laptop-ready. But it's a community re-upload under a non-commercial FAIR licence, thin model card, provenance and quant quality unverified. Can't see this replacing a fine-tuned Qwen in production yet.
- [Hacker News · g023 · 2026-04-07](https://news.ycombinator.com/item?id=47669210): Show HN: Standalone TurboQuant KV Cache Inference: A single file, python based, minimal/recognizable dependencies, turboquant playground, barebones af, with some easy to access globals to experiment with at top of 'run\_tquant.py'. Test model is a 1.77B model that I altered by duplicating a layer in a Qwen3 1.7B model. Probably work fine with the…
- [Bluesky · @aichina.news · 2026-10-17](https://bsky.app/profile/aichina.news/post/3mxzwvkkhhu2f): A 1.5B reasoning model on CPU via llama.cpp is the size class edge inference wants. But the model card ships no benchmarks and the licence reads 'other'. Qwen3-1.7B keeps this tier until NVIDIA publishes evals and legal clears the terms. \*(237 graphemes. Same reader — the practitioner weighing...
- [Hacker News · hbbio · 2025-04-30](https://news.ycombinator.com/item?id=43841495): Qwen3: Think deeper, act faster: Thanks, /nothink works\! So, Qwen3 1.7b is about the same speed just slightly worse than Gemma3 4b which is pretty impressive. Qwen3 4b passes all 200 tests and is much faster than Mistral Small 3.1 24b or Gemma3 27b.
- [Bluesky · Don Trueten :antifa: · 2026-10-09](https://bsky.app/profile/thomas.mastodon.trueten.de.ap.brid.gy/post/3mxhd6ch4lbv2): Sobald es komplexer wird, reicht Qwen3 1.7B nicht mehr. Und tschüß. Welcome to the jungle, Qwen3 4B

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2025-07-26
- First published: 2025-04-27
- Checked on Hugging Face: 2026-11-13
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open Qwen/Qwen3-1.7B on Hugging Face](https://huggingface.co/Qwen/Qwen3-1.7B)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/c3175d9e-0ec9-4f84-b948-86f012d7e396)
- [Its page on Mindket](https://mindket.com/p/c3175d9e-0ec9-4f84-b948-86f012d7e396)