> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/language-models/qwen38-27b.md).

# Qwen3.8-27B (डेंस VLM, एक कार्ड)

Clore.ai पर Qwen3.8-27B डिप्लॉय करें — Alibaba का डेंस 27B विज़न-लैंग्वेज मॉडल, जो Q4 पर एक RTX 4090 और FP8 पर एक RTX 5090 पर चलता है

{% hint style="info" %}
**स्थिति (अगस्त 2026):** Qwen ने जारी किया **Qwen3.8-27B** को **14 अगस्त 2026** के अंतर्गत **Apache 2.0**के साथ, और एक दिन बाद आधिकारिक FP8 चेकपॉइंट। वज़न: [Qwen/Qwen3.8-27B](https://huggingface.co/Qwen/Qwen3.8-27B) और [Qwen/Qwen3.8-27B-FP8](https://huggingface.co/Qwen/Qwen3.8-27B-FP8). Dense 27B, **मूलभूत विज़न-लैंग्वेज**, **262,144-टोकन संदर्भ** तक विस्तार योग्य **YaRN के साथ 1M**और vLLM, SGLang तथा llama.cpp में पहले दिन से समर्थन।
{% endhint %}

इस गर्मी में जारी हुई ज़्यादातर चीज़ें किराए पर नहीं ली जा सकतीं। GLM-5.2 FP8 में 756GB है। MiniMax M3 854GB है। Kimi K3 1.5TB है और किसी भी क्वांटाइज़ेशन पर Clore.ai पर सूचीबद्ध किसी भी मशीन में फिट नहीं होता। Qwen3.8-27B इसका संतुलन है: **27B dense पैरामीटर, Q4 पर 15.4GB, एक कार्ड, एक कंटेनर, काम पूरा।** यह वही मॉडल है जिसके लिए यह मार्केटप्लेस वास्तव में बना है — आखिरी स्नैपशॉट में 24GB या बेहतर कार्ड वाले 677 सर्वर खाली थे।

यह कोई घटाया-घटाया मॉडल भी नहीं है। यह मूल रूप से इमेज और वीडियो संभालता है, एक `reasoning_effort` डायल एक्सपोज़ करता है, और इसका हाइब्रिड अटेंशन स्टैक KV कैश को इतना छोटा रखता है कि कंज़्यूमर कार्ड पर लंबा संदर्भ सैद्धांतिक नहीं बल्कि व्यावहारिक हो जाता है।

### मुख्य विनिर्देश

| गुण              | मान                                                     |
| ---------------- | ------------------------------------------------------- |
| पैरामीटर         | 27B (डेंस)                                              |
| आर्किटेक्चर      | 64 लेयर, हाइब्रिड Gated DeltaNet + Gated Attention, MTP |
| मॉडैलिटी         | पाठ, छवि, वीडियो इन → पाठ आउट                           |
| मूल संदर्भ       | 262,144 टोकन                                            |
| विस्तारित संदर्भ | 1,000,000 टोकन (YaRN)                                   |
| लाइसेंस          | Apache 2.0                                              |
| रिलीज़ तिथि      | 14 अगस्त 2026                                           |
| वज़न             | BF16 55.6GB · FP8 30.9GB · Q4\_K\_S GGUF 15.4GB         |
| मुख्य टूलिंग     | vLLM, SGLang, llama.cpp, Ollama                         |

### क्यों यह

* **यह फिट हो जाता है।** एकल RTX 3090 या 4090 पर Q4 **$0.07–0.42/घंटा**; FP8 एक RTX PRO 6000 या 2× 24GB कार्ड पर
* **Apache 2.0** — व्यावसायिक उपयोग, फाइन-ट्यूनिंग और पुनर्वितरण बिना किसी राजस्व-शर्त के, Kimi K3 (कस्टम लाइसेंस जिसमें revenue gate है) या MiniMax M3 (community licence) के विपरीत
* **हाइब्रिड अटेंशन** — हर 4 लेयर ब्लॉक में से 3 Gated DeltaNet (linear attention) हैं, इसलिए संदर्भ के साथ KV कैश का आकार एक standard transformer की तुलना में बहुत धीमे बढ़ता है। यही कारण है कि 24GB पर 100K+ संदर्भ उपयोगी हो जाता है
* **विज़न अंतर्निर्मित** — डायग्राम, दस्तावेज़, स्क्रीनशॉट और घंटे-भर का वीडियो, तैनात करने के लिए कोई अलग VLM नहीं
* **थिंकिंग कंट्रोल** — `reasoning_effort` पर `निम्न` / `मध्यम` / `xhigh`के अलावा `preserve_thinking` एजेंट्स के लिए टर्न्स के बीच तर्क को बनाए रखने हेतु

***

## आवश्यकताएँ

{% hint style="success" %}
**एक कार्ड ही पूरा उद्देश्य है।** Q4 पर एक अकेला RTX 4090 आपको लगभग रोज़ एक कप कॉफी की कीमत में फ्रंटियर-स्तरीय विज़न-लैंग्वेज मॉडल देता है। FP8 गुणवत्ता या बहुत लंबे संदर्भ के लिए ही RTX 5090 या RTX PRO 6000 पर जाएँ।
{% endhint %}

|                   | Q4\_K\_S GGUF         | Q8 / FP8                             | BF16                            |
| ----------------- | --------------------- | ------------------------------------ | ------------------------------- |
| वज़न              | 15.4GB                | \~31GB                               | 55.6GB                          |
| GPU               | 1× RTX 3090/4090 24GB | 1× RTX PRO 6000 96GB, या 2× RTX 5090 | 2× RTX PRO 6000, या 4× RTX 5090 |
| व्यावहारिक संदर्भ | \~64K                 | \~200K                               | पूरा 262K                       |
| System RAM        | 32GB                  | 64GB                                 | 96GB                            |
| डिस्क             | 25GB                  | 45GB                                 | 80GB                            |
| CUDA              | 12.8+                 | 12.8+                                | 12.8+                           |

{% hint style="warning" %}
**एक अकेला RTX 5090 (32GB) FP8 के लिए पर्याप्त नहीं है।** सिर्फ वज़न ही 30.9GB हैं। आपको KV कैश और activations के लिए जगह चाहिए, इसलिए FP8 के लिए या तो 96GB कार्ड चाहिए या दो GPUs। एक 5090 पर Q6 या Q4 चलाएँ — देखें [CUDA और PyTorch संगतता](/guides/guides_v2-hi/getting-started/cuda-pytorch-compatibility.md) Blackwell पर सही base image के लिए।
{% endhint %}

***

## विकल्प A — Ollama (सबसे तेज़ रास्ता)

```bash
ollama pull qwen3.8:27b
ollama run qwen3.8:27b

# OpenAI-संगत endpoint
ollama serve &
curl http://localhost:11434/v1/chat/completions \\
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8:27b",
    "messages": [{"role": "user", "content": "इस handler को context.Context का उपयोग करने के लिए refactor करें और retries जोड़ें।"}],
    "temperature": 0.7
  }'
```

डिफ़ॉल्ट tag Q4\_K\_M (\~16GB) है। उपयोग करें `qwen3.8:27b-q8_0` यदि आपने 96GB कार्ड किराए पर लिया है।

***

## विकल्प B — vLLM (production)

एक 24GB कार्ड, community INT4 AWQ checkpoint:

```yaml
# docker-compose.yml
services:
  vllm:
    image: vllm/vllm-openai:latest
    ports: ["8000:8000"]
    volumes: [hf_cache:/root/.cache/huggingface]
    command: >
      --model cyankiwi/Qwen3.8-27B-AWQ-INT4
      --max-model-len 65536
      --gpu-memory-utilization 0.92
      --served-model-name qwen3.8-27b
      --enable-auto-tool-choice
      --tool-call-parser hermes
    deploy:
      resources:
        reservations:
          devices: [{driver: nvidia, count: 1, capabilities: [gpu]}]
    shm_size: "8gb"
volumes:
  hf_cache:
```

Qwen आधिकारिक रूप से केवल BF16 और FP8 जारी करता है। 4-bit checkpoints community builds हैं — `cyankiwi/Qwen3.8-27B-AWQ-INT4` और `RedHatAI/Qwen3.8-27B-INT4` सबसे अधिक डाउनलोड किए गए हैं, और `unsloth/Qwen3.8-27B-NVFP4` विशेष रूप से Blackwell कार्ड्स को लक्षित करता है।

दो GPUs पर FP8:

```bash
vllm serve Qwen/Qwen3.8-27B-FP8 \\
  --tensor-parallel-size 2 \\
  --max-model-len 262144 \\
  --gpu-memory-utilization 0.90 \
  --enable-chunked-prefill
```

वीडियो इनपुट के लिए एक अतिरिक्त flag चाहिए:

```bash
vllm serve Qwen/Qwen3.8-27B --media-io-kwargs '{"video": {"num_frames": -1}}'
```

YaRN के साथ native window से आगे बढ़ें:

```bash
VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 vllm serve Qwen/Qwen3.8-27B \\
  --hf-overrides '{"text_config": {"rope_parameters": {"rope_type": "yarn", "factor": 4.0, "original_max_position_embeddings": 262144}}}' \\
  --max-model-len 1000000
```

***

## विकल्प C — llama.cpp / GGUF (24GB कार्ड्स)

```bash
# Q4_K_S — 15.4GB, 24GB कार्ड पर आराम से चलता है
huggingface-cli download unsloth/Qwen3.8-27B-GGUF \\
  --include "*UD-Q4_K_S*" --local-dir /workspace/qwen38

llama-server -m /workspace/qwen38/*UD-Q4_K_S*.gguf \\
  --host 0.0.0.0 --port 8080 \
  -ngl 999 -c 65536 --flash-attn
```

उसी repo से छोटे quants, अधिक तंग कार्ड्स के लिए: `UD-Q3_K_XL` 13.1GB, `UD-Q2_K_XL` 9.8GB, `UD-IQ2_S` 8.4GB.

***

## तर्क प्रयास

```python
from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1", api_key="none")

resp = client.chat.completions.create(
    model="qwen3.8-27b",
    messages=[{"role": "user", "content": "माइग्रेशन को चरणों में प्लान करें."}],
    extra_body={"reasoning_effort": "xhigh"},   # xhigh (default) | medium | low
)
```

इसे घटाएँ `निम्न` classification, extraction और routing के लिए — वहाँ गुणवत्ता का अंतर छोटा होता है और token bill भी बहुत कम। रखें `xhigh` agents और multi-step code work के लिए।

***

## Clore.ai GPU अनुशंसाएँ

| सेटअप           | VRAM  | मोड        | संदर्भ    | Clore.ai लागत     |
| --------------- | ----- | ---------- | --------- | ----------------- |
| **1× RTX 3090** | 24GB  | Q4 GGUF    | \~64K     | **$0.07–0.21/hr** |
| **1× RTX 4090** | 24GB  | Q4 AWQ     | \~64K     | **$0.14–0.42/hr** |
| 1× RTX 5090     | 32GB  | Q6 GGUF    | \~96K     | $0.25–0.77/घंटा   |
| 2× RTX 5090     | 64GB  | FP8, TP=2  | \~200K    | $0.50–1.54/hr     |
| 1× RTX PRO 6000 | 96GB  | FP8        | पूरा 262K | $0.92–1.38/घं     |
| 4× RTX 5090     | 128GB | BF16, TP=4 | पूरा 262K | $1.00–3.08/घं     |

{% hint style="success" %}
**सबसे अच्छा मूल्य:** एक [RTX 4090 $0.14/घं से](https://clore.ai/rent-4090.html) Q4 पर। अगर पूरे रिग की कीमत ऊँची लगे, तो याद रखें कि ज़्यादातर multi-GPU rigs [आंशिक किराया](/guides/guides_v2-hi/getting-started/partial-gpu-rental.md) — आप आठ-कार्ड वाले बॉक्स से एक कार्ड निकाल सकते हैं।
{% endhint %}

***

## बेंचमार्क

{% hint style="warning" %}
नीचे दिए गए आंकड़े Qwen के अपने हैं, 14 अगस्त 2026 मॉडल कार्ड से। इस लेखन के समय स्वतंत्र पुनरुत्पादन अभी भी आ रहे थे।
{% endhint %}

Qwen 27B का मूल्यांकन coding और agentic suites (SWE-bench Pro, DeepSWE, QwenSWEBench) में कहीं बड़े मॉडलों के विरुद्ध 256K context पर Claude Code harness का उपयोग करके करता है। deployment के लिए मायने रखने वाला दावा कोई एक score नहीं है: यह है कि एक consumer card पर चलने वाला dense 27B उन MoE मॉडलों के साथ उसी बातचीत में आता है जिन्हें एक पूरा rack चाहिए। vendor table को शुरुआती परिकल्पना मानें और अपने task set पर benchmark करें — यहाँ यह सस्ता है, क्योंकि 4090 के एक घंटे का समय लगभग बीस सेंट पड़ता है।

***

## उपयोग के मामले

* **एकल-GPU coding assistant** — एक कंटेनर, एक कार्ड, OpenAI-संगत endpoint
* **दस्तावेज़ और स्क्रीनशॉट समझना** — मूल विज़न, कोई अलग pipeline नहीं
* **वीडियो विश्लेषण** — vLLM के frame flag के साथ एक ही pass में घंटे-भर का वीडियो
* **लंबा-संदर्भ RAG** — मूल 262K, और हाइब्रिड अटेंशन KV कैश को किफायती रखता है
* **एजेंट workers** — `preserve_thinking` tool calls के बीच तर्क को सुसंगत रखता है
* **ऑन-प्रिमाइसेस और air-gapped** — Apache 2.0, कुछ भी घर फ़ोन नहीं करता
* **LoRA फाइन-ट्यूनिंग** — 27B dense इसके लिए अनुकूल है [Unsloth](/guides/guides_v2-hi/training/unsloth-finetune.md) और [LLaMA-Factory](/guides/guides_v2-hi/training/llama-factory.md) एकल 24GB कार्ड पर

***

## समस्या निवारण

| समस्या                                    | ठीक करें                                                                                                                          |
| ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| `कोई kernel image उपलब्ध नहीं है` 5090 पर | पुराना CUDA build — cu128 image का उपयोग करें, देखें [संगतता](/guides/guides_v2-hi/getting-started/cuda-pytorch-compatibility.md) |
| एक RTX 5090 पर FP8 में OOM                | अपेक्षित: 32GB कार्ड पर 30.9GB वज़न। Q6/Q4, या TP=2 का उपयोग करें                                                                 |
| 24GB पर लंबे संदर्भ में OOM               | कम करें `--max-model-len` को 32768 तक, या घटाकर `UD-Q3_K_XL`                                                                      |
| YaRN अस्वीकार किया गया                    | एक हालिया vLLM/SGLang चाहिए; इसे इसके माध्यम से पास करें `--hf-overrides`को, standalone flag के रूप में नहीं                      |
| वीडियो इनपुट अनदेखा किया गया              | जोड़ें `--media-io-kwargs '{"video": {"num_frames": -1}}'` (केवल vLLM)                                                            |
| tool calls गिर गए                         | `--enable-auto-tool-choice --tool-call-parser hermes`                                                                             |
| लगभग 600K के बाद गुणवत्ता गिरती है        | YaRN positions को बढ़ाता है, समझ को नहीं — महत्वपूर्ण सामग्री को prompt के अंत के पास रखें                                        |

***

## अगले चरण

* **पूर्ववर्ती:** [Qwen3.6-27B](/guides/guides_v2-hi/language-models/qwen36-27b.md) — इस अप्रैल वाले dense 27B का स्थानापन्न
* **मल्टीमॉडल सहोदर:** [Qwen3.5-Omni](/guides/guides_v2-hi/language-models/qwen35-omni.md) — audio in और speech out जोड़ता है
* **ऊपर जाएँ:** [GLM-5.2](/guides/guides_v2-hi/language-models/glm-5-2.md) या [Mistral Small 4](/guides/guides_v2-hi/language-models/mistral-small4.md) जब 27B पर्याप्त न हो
* **Serving:** [vLLM](/guides/guides_v2-hi/language-models/vllm.md) · [SGLang](/guides/guides_v2-hi/language-models/sglang.md) · [Ollama](/guides/guides_v2-hi/language-models/ollama.md)
* **इसे fine-tune करें:** [Unsloth](/guides/guides_v2-hi/training/unsloth-finetune.md)

### लिंक्स

* [Hugging Face पर Qwen3.8-27B](https://huggingface.co/Qwen/Qwen3.8-27B) · [FP8](https://huggingface.co/Qwen/Qwen3.8-27B-FP8) · [GGUF](https://huggingface.co/unsloth/Qwen3.8-27B-GGUF)
* [vLLM रेसिपी](https://recipes.vllm.ai/Qwen/Qwen3.8-27B) · [SGLang कुकबुक](https://docs.sglang.io/cookbook/autoregressive/Qwen/Qwen3.8-27B)
* [Qwen ब्लॉग](https://qwenlm.github.io/)
* **GPU किराये पर लें:** [RTX 4090](https://clore.ai/rent-4090.html) · [RTX 5090](https://clore.ai/rent-5090.html) · [मार्केटप्लेस](https://clore.ai/marketplace)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-hi/language-models/qwen38-27b.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.