# GLM-4.7-Flash

> GLM-4.7-Flash es un **modelo de lenguaje Mixture-of-Experts de 30 mil millones de parámetros** de Zhipu AI que activa solo 3B de parámetros por token. Ofrece un rendimiento excepcional en tareas de codificación y razonamiento, alcanzando 59.2% en SWE-bench mientras requiere solo 10-12GB de VRAM para inferencia FP16. Publicado bajo la **licencia MIT**, es una opción ideal para desarrolladores que buscan calidad de modelo de vanguardia a costos asequibles en una sola GPU.

## A simple vista

* **Tamaño del modelo**: 30B total / 3B parámetros activos (MoE)
* **Licencia**: MIT (comercialmente completo)
* **Contexto**: 128K tokens
* **Rendimiento**: 59.2% SWE-bench, 75.4% HumanEval
* **VRAM**: \~10-12GB FP16, \~6GB INT8
* **Velocidad**: \~45-60 tok/s en RTX 4090

## ¿Por qué GLM-4.7-Flash?

**Rendimiento eficiente**: GLM-4.7-Flash rinde por encima de su categoría. A pesar de usar solo 3B de parámetros activos, supera a muchos modelos densos de 70B+ en benchmarks de codificación. La arquitectura MoE proporciona calidad de modelo de 30B al costo de inferencia de un modelo de 7B.

**Compatible con una sola GPU**: A diferencia de modelos masivos que requieren configuraciones multi-GPU, GLM-4.7-Flash funciona cómodamente en una sola RTX 4090 o en una A100 de 40GB. Esto lo hace perfecto para desarrollo, fine-tuning y despliegues en producción rentables.

**Especialista en codificación**: Con 59.2% en SWE-bench, GLM-4.7-Flash sobresale en tareas de ingeniería de software — generación de código, depuración, refactorización y documentación técnica. Entiende más de 20 lenguajes de programación con profunda conciencia del contexto.

**Con licencia MIT**: Sin restricciones de uso. Despliega comercialmente, afina o modifica sin preocupaciones de licencia. Los pesos completos y las recetas de entrenamiento están disponibles libremente.

## Recomendaciones de GPU

| GPU          | VRAM | Rendimiento | Costo diario\* |
| ------------ | ---- | ----------- | -------------- |
| **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        |

**Mejor valor**: La RTX 4090 ofrece el punto óptimo entre rendimiento y costo para GLM-4.7-Flash.

\*Precios estimados del marketplace de Clore.ai

## Desplegar con vLLM

### Instalar vLLM

```bash
pip install vllm>=0.6.0
# o la última
pip install git+https://github.com/vllm-project/vllm.git
```

### Configuración de GPU única

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

### Consultar el servidor

```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": "Eres un desarrollador Python experto."},
        {"role": "user", "content": "Escribe una aplicación FastAPI con SQLAlchemy asíncrono y autenticación JWT"}
    ],
    max_tokens=2048,
    temperature=0.7
)

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

## Desplegar con SGLang

SGLang a menudo brinda mejor rendimiento para modelos MoE:

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

# Iniciar servidor
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
```

## Desplegar con Ollama

Configuración simple para desarrollo local:

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

# Descargar modelo (descargará ~18GB)
ollama pull glm4:7b-chat

# Ejecutar interactivamente
ollama run glm4:7b-chat

# Modo API
ollama serve
```

Luego consulta vía API REST:

```python
import requests

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

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

## Plantilla Docker

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

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

# Instalar vLLM
RUN pip install vllm>=0.6.0 transformers

# Pre-descargar modelo (opcional)
# 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"]
```

Construir y ejecutar:

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

## Ejemplo de generación de código

GLM-4.7-Flash sobresale en generación de código compleja:

```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": """Crea una clase en Python para un limitador de tasa con:
- Algoritmo de cubo de tokens
- Soporte Async/await  
- Backend en Redis
- Decorador para limitar la tasa de funciones
- Manejo de errores adecuado"""}
    ],
    max_tokens=2048,
    temperature=0.3
)

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

## Consejos para usuarios de Clore.ai

* **Optimización de memoria**: Usa `--dtype float16` para reducir el uso de VRAM. Para GPUs de 16GB, añade `--max-model-len 16384` para limitar el contexto.
* **Procesamiento por lotes**: Aumenta `--max-num-seqs` para mayor rendimiento al servir múltiples solicitudes.
* **Cuantización**: Para RTX 3060/4060 (12GB), usa versiones cuantizadas AWQ o GPTQ para \~6GB de uso de VRAM.
* **Preempción**: GLM-4.7-Flash maneja interrupciones con gracia — bueno para instancias preemptibles de Clore.ai.
* **Longitud de contexto**: El contexto por defecto de 128K puede ser excesivo. Ajusta `--max-model-len 32768` para la mayoría de las aplicaciones.

## Solución de problemas

| Problema               | Solución                                                   |
| ---------------------- | ---------------------------------------------------------- |
| `OutOfMemoryError`     | Reduce `--max-model-len` o usa `--dtype float16`           |
| Carga lenta del modelo | Pre-cache con `huggingface-cli download THUDM/glm-4-flash` |
| Errores de importación | Actualiza transformers: `pip install transformers>=4.40.0` |
| Rendimiento pobre      | Habilita Flash Attention: `pip install flash-attn`         |
| Conexión rechazada     | Revisa el firewall: `ufw allow 8000`                       |

## Modelos alternativos

Si GLM-4.7-Flash no se ajusta a tus necesidades:

* **Qwen2.5-Coder-7B**: Mejor para codificación pura, menor huella
* **CodeQwen1.5-7B**: Especialista en codificación en chino + inglés
* **GLM-4-9B**: Hermano mayor con mejor razonamiento
* **DeepSeek-V3**: MoE de 671B para rendimiento máximo (multi-GPU)

## Recursos

* [GLM-4-Flash en Hugging Face](https://huggingface.co/THUDM/glm-4-flash)
* [Informe técnico de GLM-4](https://arxiv.org/abs/2406.12793)
* [Documentación de vLLM](https://docs.vllm.ai/)
* [SGLang en GitHub](https://github.com/sgl-project/sglang)
* [Plataforma Zhipu AI](https://open.bigmodel.cn/)


---

# Agent Instructions: 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:

```
GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/glm-47-flash.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.