> 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-es/modelos-de-lenguaje/glm-47-flash.md).

# GLM-4.7-Flash

Despliega GLM-4.7-Flash (30B MoE) de Zhipu AI en Clore.ai: modelo de lenguaje eficiente con un 59.2% de rendimiento en SWE-bench

> GLM-4.7-Flash es un **modelo de mezcla de expertos de 30 mil millones de parámetros** modelo de lenguaje de Zhipu AI que activa solo 3 mil millones de parámetros por token. Ofrece un rendimiento excepcional en tareas de programación y razonamiento, alcanzando un 59.2% en SWE-bench mientras requiere solo 10-12 GB de VRAM para inferencia FP16. Lanzado bajo la **licencia MIT**, es una opción ideal para desarrolladores que buscan calidad de modelo de frontera a un coste asequible en una sola GPU.

## De un vistazo

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

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

**Rendimiento eficiente**: GLM-4.7-Flash supera lo que cabría esperar de su tamaño. A pesar de usar solo 3B parámetros activos, supera a muchos modelos densos de 70B+ en benchmarks de programación. La arquitectura MoE ofrece la calidad de un modelo de 30B al coste de inferencia de un modelo de 7B.

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

**Especialista en programación**: Con un 59.2% en SWE-bench, GLM-4.7-Flash destaca 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 una profunda conciencia del contexto.

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

## Recomendaciones de GPU

| GPU          | VRAM  | Rendimiento | Coste diario\* |
| ------------ | ----- | ----------- | -------------- |
| **RTX 4090** | 24GB  | \~50 tok/s  | \~$2.10        |
| **RTX 3090** | 24GB  | \~35 tok/s  | \~$1.10        |
| A100 40GB    | 40 GB | \~80 tok/s  | \~$3.50        |
| A100 80GB    | 80 GB | \~90 tok/s  | \~$4.00        |
| H100         | 80 GB | \~120 tok/s | \~$6.00        |

**Mejor relación calidad-precio**: La RTX 4090 ofrece el punto óptimo entre rendimiento y coste para GLM-4.7-Flash.

\*Precios estimados del marketplace de Clore.ai

## Despliega con vLLM

### Instalar vLLM

```bash
pip install vllm>=0.6.0
# o la versión más reciente
pip install git+https://github.com/vllm-project/vllm.git
```

### Configuración para una sola 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
```

### 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 experto de Python."},
        {"role": "user", "content": "Escribe una app 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 ofrece 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 sencilla para desarrollo local:

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

# Descarga el modelo (se descargarán ~18GB)
ollama pull glm4:7b-chat

# Ejecutar de forma interactiva
ollama run glm4:7b-chat

# Modo API
ollama serve
```

Luego consulta mediante la 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 de Docker

```dockerfile
FROM nvidia/cuda:12.8.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 el 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 destaca 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 de Python para un limitador de tasa con:
- Algoritmo de token bucket
- Compatibilidad con async/await  
- Backend de Redis
- Decorador para limitar la tasa de funciones
- Manejo adecuado de errores"""}
    ],
    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 16 GB, añade `--max-model-len 16384` para limitar el contexto.
* **Procesamiento por lotes**: Aumenta `--max-num-seqs` para obtener mayor rendimiento al servir múltiples solicitudes.
* **Cuantización**: Para RTX 3060/4060 (12GB), usa versiones cuantizadas AWQ o GPTQ para un uso de \~6GB de VRAM.
* **Preempción**: GLM-4.7-Flash maneja las interrupciones con elegancia — ideal para instancias preemptibles de Clore.ai.
* **Longitud del contexto**: El contexto predeterminado de 128K puede ser excesivo. Establece `--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 | Precárgalo con `huggingface-cli download THUDM/glm-4-flash` |
| Errores de importación | Actualiza transformers: `pip install transformers>=4.40.0`  |
| Rendimiento deficiente | Activa Flash Attention: `pip install flash-attn`            |
| Conexión rechazada     | Verifica el firewall: `ufw allow 8000`                      |

## Modelos alternativos

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

* **Qwen2.5-Coder-7B**: Mejor programación pura, menor huella
* **CodeQwen1.5-7B**: Especialista en programación en chino e inglés
* **GLM-4-9B**: Versión mayor con mejor razonamiento
* **DeepSeek-V3**: MoE de 671B para el máximo rendimiento (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/)
* [GitHub de SGLang](https://github.com/sgl-project/sglang)
* [Plataforma de 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-es/modelos-de-lenguaje/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.