> 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-fr/modeles-de-langage/glm-47-flash.md).

# GLM-4.7-Flash

Déployez GLM-4.7-Flash (MoE 30B) de Zhipu AI sur Clore.ai — modèle de langage efficace avec 59,2 % de performance SWE-bench

> GLM-4.7-Flash est un **Mixture-of-Experts de 30 milliards de paramètres** modèle de langage de Zhipu AI qui n'active que 3B paramètres par jeton. Il offre des performances exceptionnelles sur les tâches de codage et de raisonnement, atteignant 59,2 % sur SWE-bench tout en ne nécessitant que 10-12 Go de VRAM pour l'inférence FP16. Publié sous le **licence MIT**, c'est un choix idéal pour les développeurs à la recherche d'une qualité de modèle de pointe à un coût abordable sur une seule GPU.

## En un coup d'œil

* **Taille du modèle**: 30B au total / 3B de paramètres actifs (MoE)
* **Licence**: MIT (utilisation commerciale totale)
* **Contexte**: 128K jetons
* **Performances**: 59,2 % SWE-bench, 75,4 % HumanEval
* **VRAM**: \~10-12 Go FP16, \~6 Go INT8
* **Vitesse**: \~45-60 tok/s sur RTX 4090

## Pourquoi GLM-4.7-Flash ?

**Performances efficaces**: GLM-4.7-Flash surpasse sa catégorie. Malgré l'utilisation de seulement 3B paramètres actifs, il dépasse de nombreux modèles denses de 70B+ sur les benchmarks de codage. L'architecture MoE offre la qualité d'un modèle de 30B au coût d'inférence d'un modèle de 7B.

**Compatible avec une seule GPU**: Contrairement aux modèles massifs nécessitant des configurations multi-GPU, GLM-4.7-Flash fonctionne confortablement sur une seule RTX 4090 ou une A100 40 Go. Cela en fait un choix parfait pour le développement, le fine-tuning et les déploiements de production rentables.

**Spécialiste du code**: Avec des performances de 59,2 % sur SWE-bench, GLM-4.7-Flash excelle dans les tâches d'ingénierie logicielle — génération de code, débogage, refactorisation et documentation technique. Il comprend plus de 20 langages de programmation avec une connaissance approfondie du contexte.

**Sous licence MIT**: Aucune restriction d'utilisation. Déployez commercialement, affinez ou modifiez sans souci de licence. Les poids complets et les recettes d'entraînement sont librement disponibles.

## Recommandations GPU

| GPU          | VRAM  | Performances | Coût journalier\* |
| ------------ | ----- | ------------ | ----------------- |
| **RTX 4090** | 24GB  | \~50 tok/s   | \~$2.10           |
| **RTX 3090** | 24GB  | \~35 tok/s   | \~$1.10           |
| A100 40 Go   | 40 Go | \~80 tok/s   | \~$3.50           |
| A100 80 Go   | 80 Go | \~90 tok/s   | \~$4.00           |
| H100         | 80 Go | \~120 tok/s  | \~$6.00           |

**Meilleur rapport qualité-prix**: La RTX 4090 offre le meilleur compromis entre performances et coût pour GLM-4.7-Flash.

\*Prix estimés sur la place de marché Clore.ai

## Déployer avec vLLM

### Installer vLLM

```bash
pip install vllm>=0.6.0
# ou la version la plus récente
pip install git+https://github.com/vllm-project/vllm.git
```

### Configuration sur GPU unique

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

### Interroger le serveur

```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": "Vous êtes un développeur Python expert."},
        {"role": "user", "content": "Écrivez une application FastAPI avec SQLAlchemy asynchrone et authentification JWT"}
    ],
    max_tokens=2048,
    temperature=0.7
)

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

## Déployer avec SGLang

SGLang offre souvent un meilleur débit pour les modèles MoE :

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

# Lancer le serveur
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
```

## Déployer avec Ollama

Configuration simple pour le développement local :

```bash
# Installer Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Télécharger le modèle (téléchargera ~18 Go)
ollama pull glm4:7b-chat

# Exécuter en mode interactif
ollama run glm4:7b-chat

# Mode API
ollama serve
```

Interrogez ensuite via l'API REST :

```python
import requests

response = requests.post('http://localhost:11434/api/generate',
    json={
        'model': 'glm4:7b-chat',
        'prompt': 'Expliquez l'architecture MoE dans GLM-4.7-Flash',
        'stream': False
    }
)

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

## Modèle Docker

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

# Installer Python 3.10
RUN apt-get update && apt-get install -y python3.10 python3-pip curl

# Installer vLLM
RUN pip install vllm>=0.6.0 transformers

# Pré-télécharger le modèle (facultatif)
# 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"]
```

Construire et exécuter :

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

## Exemple de génération de code

GLM-4.7-Flash excelle dans la génération de code complexe :

```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": """Créez une classe Python pour un limiteur de débit avec :
- Algorithme du seau à jetons
- Prise en charge d'async/await  
- Backend Redis
- Décorateur pour la limitation de débit des fonctions
- Gestion d'erreurs appropriée"""}
    ],
    max_tokens=2048,
    temperature=0.3
)

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

## Conseils pour les utilisateurs de Clore.ai

* **Optimisation de la mémoire**: Utilisez `--dtype float16` pour réduire l'utilisation de la VRAM. Pour les GPU de 16 Go, ajoutez `--max-model-len 16384` pour limiter le contexte.
* **Traitement par lots**: Augmentez `--max-num-seqs` pour un débit plus élevé lors du service de plusieurs requêtes.
* **Quantification**: Pour les RTX 3060/4060 (12 Go), utilisez des versions quantifiées AWQ ou GPTQ pour une utilisation d'environ 6 Go de VRAM.
* **Préemption**: GLM-4.7-Flash gère les interruptions avec élégance — idéal pour les instances préemptibles de Clore.ai.
* **Longueur de contexte**: Le contexte par défaut de 128K peut être excessif. Définissez `--max-model-len 32768` pour la plupart des applications.

## Dépannage

| Problème                  | Solution                                                                     |
| ------------------------- | ---------------------------------------------------------------------------- |
| `OutOfMemoryError`        | Réduisez `--max-model-len` ou utilisez `--dtype float16`                     |
| Chargement du modèle lent | Mettez en cache à l'avance avec `huggingface-cli download THUDM/glm-4-flash` |
| Erreurs d'importation     | Mettre à jour transformers : `pip install transformers>=4.40.0`              |
| Mauvaises performances    | Activez Flash Attention : `pip install flash-attn`                           |
| Connexion refusée         | Vérifiez le pare-feu : `ufw allow 8000`                                      |

## Modèles alternatifs

Si GLM-4.7-Flash ne répond pas à vos besoins :

* **Qwen2.5-Coder-7B**: Meilleur pour le codage pur, empreinte plus réduite
* **CodeQwen1.5-7B**: Spécialiste du codage en chinois et en anglais
* **GLM-4-9B**: Grand frère plus large avec de meilleures capacités de raisonnement
* **DeepSeek-V3**: MoE de 671B pour des performances ultimes (multi-GPU)

## Ressources

* [GLM-4-Flash sur Hugging Face](https://huggingface.co/THUDM/glm-4-flash)
* [Rapport technique GLM-4](https://arxiv.org/abs/2406.12793)
* [Documentation vLLM](https://docs.vllm.ai/)
* [GitHub de SGLang](https://github.com/sgl-project/sglang)
* [Plateforme 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-fr/modeles-de-langage/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.