> 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/glm-47-flash.md).

# GLM-4.7-Flash

Clore.ai पर Zhipu AI द्वारा GLM-4.7-Flash (30B MoE) डिप्लॉय करें — 59.2% SWE-bench प्रदर्शन वाला कुशल भाषा मॉडल

> GLM-4.7-Flash एक **30 अरब पैरामीटर वाला Mixture-of-Experts** Zhipu AI का भाषा मॉडल है जो प्रति टोकन केवल 3B पैरामीटर सक्रिय करता है। यह कोडिंग और तर्क-वितर्क कार्यों में असाधारण प्रदर्शन देता है, SWE-bench पर 59.2% हासिल करता है, जबकि FP16 इन्फरेंस के लिए केवल 10-12GB VRAM की आवश्यकता होती है। के अंतर्गत जारी किया गया **MIT लाइसेंस**, यह फ्रंटियर मॉडल गुणवत्ता को किफायती सिंगल-GPU लागत पर चाहने वाले डेवलपर्स के लिए एक आदर्श विकल्प है।

## संक्षेप में

* **मॉडल आकार**: 30B कुल / 3B सक्रिय पैरामीटर (MoE)
* **लाइसेंस**: MIT (पूर्णतः व्यावसायिक)
* **संदर्भ**: 128K टोकन
* **प्रदर्शन**: 59.2% SWE-bench, 75.4% HumanEval
* **VRAM**: \~10-12GB FP16, \~6GB INT8
* **गति**: RTX 4090 पर \~45-60 tok/s

## GLM-4.7-Flash क्यों?

**कुशल प्रदर्शन**: GLM-4.7-Flash अपने वज़न से कहीं बढ़कर प्रदर्शन करता है। केवल 3B सक्रिय पैरामीटर इस्तेमाल करने के बावजूद, यह कोडिंग बेंचमार्क्स पर कई 70B+ dense मॉडलों से बेहतर प्रदर्शन करता है। MoE आर्किटेक्चर 7B मॉडल इन्फरेंस लागत पर 30B मॉडल-स्तर की गुणवत्ता प्रदान करता है।

**सिंगल-GPU के अनुकूल**: बड़े मॉडलों के विपरीत, जिन्हें मल्टी-GPU सेटअप की आवश्यकता होती है, GLM-4.7-Flash एक अकेले RTX 4090 या A100 40GB पर आराम से चलता है। यह इसे डेवलपमेंट, फाइन-ट्यूनिंग और लागत-प्रभावी प्रोडक्शन डिप्लॉयमेंट के लिए एकदम उपयुक्त बनाता है।

**कोडिंग विशेषज्ञ**: 59.2% SWE-bench प्रदर्शन के साथ, GLM-4.7-Flash सॉफ्टवेयर इंजीनियरिंग कार्यों — कोड जनरेशन, डिबगिंग, रिफैक्टरिंग और तकनीकी दस्तावेज़ीकरण — में उत्कृष्ट है। यह गहरी संदर्भ-जागरूकता के साथ 20+ प्रोग्रामिंग भाषाओं को समझता है।

**MIT लाइसेंस प्राप्त**: कोई उपयोग प्रतिबंध नहीं। लाइसेंस संबंधी चिंताओं के बिना इसे व्यावसायिक रूप से डिप्लॉय, फाइन-ट्यून या संशोधित करें। पूरे वज़न और प्रशिक्षण रेसिपीज़ स्वतंत्र रूप से उपलब्ध हैं।

## GPU सिफारिशें

| GPU          | VRAM | प्रदर्शन    | दैनिक लागत\* |
| ------------ | ---- | ----------- | ------------ |
| **RTX 4090** | 24GB | \~50 tok/s  | \~$2.10      |
| **RTX 3090** | 24GB | \~35 tok/s  | \~$1.10      |
| A100 40GB    | 40GB | \~80 tok/s  | \~$3.50      |
| A100 80GB    | 80GB | \~90 tok/s  | \~$4.00      |
| H100         | 80GB | \~120 tok/s | \~$6.00      |

**सर्वोत्तम मूल्य**: RTX 4090, GLM-4.7-Flash के लिए प्रदर्शन और लागत का सर्वोत्तम संतुलन प्रदान करता है।

\*Clore.ai बाज़ार के अनुमानित मूल्य

## vLLM के साथ डिप्लॉय करें

### vLLM इंस्टॉल करें

```bash
pip install vllm>=0.6.0
# या नवीनतम
pip install git+https://github.com/vllm-project/vllm.git
```

### एकल GPU सेटअप

```bash
vllm serve THUDM/glm-4-flash \
  --model THUDM/glm-4-flash \
  --tensor-parallel-size 1 \
  --dtype float16 \\
  --max-model-len 32768 \\
  --served-model-name glm-4.7-flash \
  --trust-remote-code
```

### सर्वर से क्वेरी करें

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1", 
    api_key="EMPTY"
)

response = client.chat.completions.create(
    model="glm-4.7-flash",
    messages=[
        {"role": "system", "content": "आप एक विशेषज्ञ Python डेवलपर हैं।"},
        {"role": "user", "content": "एक FastAPI ऐप लिखें जिसमें async SQLAlchemy और JWT auth हो"}
    ],
    max_tokens=2048,
    temperature=0.7
)

print(response.choices[0].message.content)
```

## SGLang के साथ डिप्लॉय करें

SGLang अक्सर MoE मॉडलों के लिए बेहतर थ्रूपुट प्रदान करता है:

```bash
pip install "sglang[all]>=0.3.0"

# सर्वर प्रारंभ करें
python -m sglang.launch_server \
  --model-path THUDM/glm-4-flash \
  --port 30000 \
  --host 0.0.0.0 \\
  --dtype float16 \\
  --tp-size 1 \
  --context-length 32768
```

## Ollama के साथ परिनियोजन करें

स्थानीय विकास के लिए सरल सेटअप:

```bash
# Ollama इंस्टॉल करें
curl -fsSL https://ollama.com/install.sh | sh

# मॉडल खींचें (लगभग ~18GB डाउनलोड होगा)
ollama pull glm4:7b-chat

# इंटरैक्टिव रूप से चलाएँ
ollama run glm4:7b-chat

# API मोड
ollama serve
```

फिर REST API के माध्यम से क्वेरी करें:

```python
import requests

response = requests.post('http://localhost:11434/api/generate',
    json={
        'model': 'glm4:7b-chat',
        'prompt': 'GLM-4.7-Flash में MoE आर्किटेक्चर समझाएँ',
        'stream': False
    }
)

print(response.json()['response'])
```

## Docker टेम्पलेट

```dockerfile
FROM nvidia/cuda:12.8.1-devel-ubuntu22.04

# Python 3.10 स्थापित करें
RUN apt-get update && apt-get install -y python3.10 python3-pip curl

# vLLM स्थापित करें
RUN pip install vllm>=0.6.0 transformers

# मॉडल पहले से डाउनलोड करें (वैकल्पिक)
# RUN python3 -c "from transformers import AutoModel; AutoModel.from_pretrained('THUDM/glm-4-flash', trust_remote_code=True)"

EXPOSE 8000

CMD ["vllm", "serve", "THUDM/glm-4-flash", \
     "--host", "0.0.0.0", \\
     "--port", "8000", \
     "--tensor-parallel-size", "1", \
     "--dtype", "float16", \
     "--trust-remote-code"]
```

बिल्ड और रन करें:

```bash
docker build -t glm-4.7-flash .
docker run --gpus all -p 8000:8000 glm-4.7-flash
```

## कोड जनरेशन उदाहरण

GLM-4.7-Flash जटिल कोड जनरेशन में उत्कृष्ट है:

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

response = client.chat.completions.create(
    model="glm-4.7-flash",
    messages=[
        {"role": "user", 
         "content": """एक rate limiter के लिए Python class बनाइए जिसमें:
- टोकन बकेट एल्गोरिद्म
- Async/await समर्थन  
- Redis बैकएंड
- फ़ंक्शन rate limiting के लिए डेकोरेटर
- उचित त्रुटि प्रबंधन"""}
    ],
    max_tokens=2048,
    temperature=0.3
)

print(response.choices[0].message.content)
```

## Clore.ai उपयोगकर्ताओं के लिए सुझाव

* **मेमोरी अनुकूलन**: उपयोग करें `--dtype float16` VRAM उपयोग कम करने के लिए। 16GB GPUs के लिए, जोड़ें `--max-model-len 16384` संदर्भ सीमित करने के लिए।
* **बैच प्रोसेसिंग**: बढ़ाएँ `--max-num-seqs` कई अनुरोधों को सेवा देते समय अधिक थ्रूपुट के लिए।
* **क्वांटाइज़ेशन**: RTX 3060/4060 (12GB) के लिए, \~6GB VRAM उपयोग हेतु AWQ या GPTQ quantized संस्करणों का उपयोग करें।
* **प्रीएम्प्शन**: GLM-4.7-Flash व्यवधानों को सहजता से संभालता है — preemptible Clore.ai instances के लिए अच्छा।
* **संदर्भ लंबाई**: डिफ़ॉल्ट 128K संदर्भ ज़रूरत से ज़्यादा हो सकता है। सेट करें `--max-model-len 32768` अधिकांश अनुप्रयोगों के लिए।

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

| समस्या              | समाधान                                                         |
| ------------------- | -------------------------------------------------------------- |
| `OutOfMemoryError`  | कम करें `--max-model-len` या उपयोग करें `--dtype float16`      |
| मॉडल लोडिंग धीमी है | पहले से कैश करें: `huggingface-cli download THUDM/glm-4-flash` |
| इंपोर्ट त्रुटियाँ   | transformers अपडेट करें: `pip install transformers>=4.40.0`    |
| खराब प्रदर्शन       | Flash Attention सक्षम करें: `pip install flash-attn`           |
| कनेक्शन अस्वीकृत    | फ़ायरवॉल जाँचें: `ufw allow 8000`                              |

## वैकल्पिक मॉडल

यदि GLM-4.7-Flash आपकी ज़रूरतों के अनुरूप नहीं है:

* **Qwen2.5-Coder-7B**: बेहतर शुद्ध कोडिंग, छोटा फ़ुटप्रिंट
* **CodeQwen1.5-7B**: चीनी + अंग्रेज़ी कोडिंग विशेषज्ञ
* **GLM-4-9B**: बेहतर तर्क क्षमता वाला बड़ा भाई
* **DeepSeek-V3**: सर्वोत्तम प्रदर्शन के लिए 671B MoE (मल्टी-GPU)

## संसाधन

* [Hugging Face पर GLM-4-Flash](https://huggingface.co/THUDM/glm-4-flash)
* [GLM-4 तकनीकी रिपोर्ट](https://arxiv.org/abs/2406.12793)
* [vLLM प्रलेखन](https://docs.vllm.ai/)
* [SGLang GitHub](https://github.com/sgl-project/sglang)
* [Zhipu AI प्लेटफ़ॉर्म](https://open.bigmodel.cn/)


---

# 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/glm-47-flash.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.