> 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

> 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 टोक/सेक

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

**कुशल प्रदर्शन**: GLM-4.7-Flash अपने वर्ग से बेहतर प्रदर्शन करता है। केवल 3B सक्रिय पैरामीटर का उपयोग करने के बावजूद यह कई 70B+ घने मॉडलों को कोडिंग बेंचमार्क पर पीछे छोड़ देता है। 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 टोक/सेक  | \~$2.10      |
| **RTX 3090** | 24GB | \~35 टोक/सेक  | \~$1.10      |
| A100 40GB    | 40GB | \~80 टोक/सेक  | \~$3.50      |
| A100 80GB    | 80GB | \~90 टोक/सेक  | \~$4.00      |
| H100         | 80GB | \~120 टोक/सेक | \~$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": "You are an expert Python developer."},
        {"role": "user", "content": "Write a FastAPI app with async SQLAlchemy and JWT auth"}
    ],
    max_tokens=2048,
    temperature=0.7
)

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

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

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

```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': 'Explain the MoE architecture in GLM-4.7-Flash',
        'stream': False
    }
)

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

## Docker टेम्पलेट

```dockerfile
FROM nvidia/cuda:12.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": """Create a Python class for a rate limiter with:
- Token bucket algorithm
- Async/await support  
- Redis backend
- Decorator for function rate limiting
- Proper error handling"""}
    ],
    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 क्वांटाइज़ किए गए संस्करणों का उपयोग करें।
* **प्रेप्शन**: GLM-4.7-Flash व्यवधानों को सुगमता से संभालता है — प्रेप्टिमेबल Clore.ai इंस्टेंस के लिए अच्छा है।
* **संदर्भ लंबाई**: डिफ़ॉल्ट 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.