# DeepSeek V4 (1.6T MoE, Multimodal)

{% hint style="info" %}
**Estado (29 de abril de 2026):** DeepSeek V4 se lanzó el **22 de abril de 2026** con **pesos totalmente abiertos bajo licencia MIT**. Hay dos checkpoints disponibles: [deepseek-ai/DeepSeek-V4-Pro](https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro) (1,6T total / \~49B activos, contexto de 1M) y [deepseek-ai/DeepSeek-V4-Flash](https://huggingface.co/deepseek-ai/DeepSeek-V4-Flash) (284B total / \~13B activos). El modelo Pro ya superó **174 mil descargas en su primera semana**y cuenta con soporte desde el día 0 en vLLM y SGLang.
{% endhint %}

DeepSeek V4 es el primer modelo de frontera de pesos abiertos de 2026 que se publica como una **versión de dos niveles**. **V4-Pro** es el buque insignia — un **Mixture-of-Experts de 1,6 billones de parámetros** con aproximadamente **49B parámetros activos por token**, una **ventana de contexto de 1M tokens**y un diseño de atención híbrida que combina Compressed Sparse Attention con una nueva cabeza de Heavily Compressed Attention para un prefill de contexto largo de bajo costo. **V4-Flash** es el hermano práctico — **284B totales / 13B activos**, la misma arquitectura, cabe en una sola GPU de 80 GB cuando se cuantiza y funciona cómodamente en una máquina 2×48 GB con builds Unsloth GGUF.

La arquitectura es el gran titular. La atención híbrida de DeepSeek reduce drásticamente el uso de memoria de la KV cache en contextos largos, y el router MoE ha sido reentrenado para una selección de expertos más precisa — ejecuciones independientes tempranas informan que Pro alcanza puntuaciones de codificación del nivel de V3 con aproximadamente la mitad del cómputo de parámetros activos. Para los usuarios de Clore.ai esto importa porque **V4-Flash es la primera vez que un modelo de frontera con menos de 15B parámetros activos se publica con pesos completos**, poniendo la inferencia abierta seria al alcance de una sola H100 o de una caja barata con varias RTX 4090.

Para la mayoría de los equipos, el despliegue realista en Clore es **V4-Flash en 1× A100 80GB o 2× RTX 4090** — ahí es donde está la mejor relación precio-rendimiento. V4-Pro se reserva para infraestructura seria: 8× H100, 4× H200 o 8× B200, idealmente con NVLink. Si has estado ejecutando [DeepSeek V3](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-v3.md) o [DeepSeek-R1](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-r1.md), la ruta de migración es sencilla — misma familia de modelo, misma plantilla de chat, sustitución directa en vLLM.

### Especificaciones clave

| Propiedad                | DeepSeek V4-Pro                                                                   | DeepSeek V4-Flash                                                                     |
| ------------------------ | --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
| Parámetros totales       | 1,6T (MoE)                                                                        | 284B (MoE)                                                                            |
| Parámetros activos       | \~49B por token                                                                   | \~13B por token                                                                       |
| Ventana de contexto      | 1.000.000 tokens                                                                  | 256.000 tokens                                                                        |
| Atención                 | Compressed Sparse + Heavily Compressed Attention                                  | Compressed Sparse + HCA                                                               |
| Licencia                 | MIT                                                                               | MIT                                                                                   |
| Fecha de lanzamiento     | 22 de abril de 2026                                                               | 22 de abril de 2026                                                                   |
| HuggingFace              | [deepseek-ai/DeepSeek-V4-Pro](https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro) | [deepseek-ai/DeepSeek-V4-Flash](https://huggingface.co/deepseek-ai/DeepSeek-V4-Flash) |
| Herramientas principales | vLLM, SGLang (día 0)                                                              | vLLM, SGLang, llama.cpp (Unsloth GGUF)                                                |

### ¿Por qué DeepSeek V4?

* **Pesos de frontera realmente abiertos** — licencia MIT, sin restricciones de uso, uso comercial completo
* **1M de contexto en Pro, 256K en Flash** — maneja bases de código completas, libros o transcripciones de una hora en una sola pasada
* **Atención dispersa híbrida** — la KV cache escala sublinealmente en contextos largos, el prefill es barato
* **Versión de dos niveles** — Flash es el primer MoE con 13B activos lo bastante bueno como para reemplazar V3 en la mayoría de los flujos de trabajo
* **Soporte en vLLM y SGLang desde el día 0** — sin esperar parches de la comunidad, solo `pip install -U` y listo
* **Eficiencia MoE** — pagas el costo de inferencia de 13B/49B, no de 284B/1,6T

***

## Requisitos

{% hint style="warning" %}
**V4-Pro es un modelo de frontera.** Los pesos BF16 completos ocupan unos 3,2TB y requieren H100/H200 multinodo o 8× B200 NVLink. No existe una ruta BF16 en un solo servidor. Si no tienes infraestructura multinodo, ejecuta V4-Flash — ofrece el 80% de la calidad con solo el 5% del costo de hardware.
{% endhint %}

| Componente  | Mínimo (V4-Flash, GGUF Q4) | Recomendado (V4-Flash FP8)  | V4-Pro completo (BF16)           |
| ----------- | -------------------------- | --------------------------- | -------------------------------- |
| VRAM de GPU | 1× 80GB o 2× 48GB          | 1× H100 80GB o 1× A100 80GB | 8× H100 80GB o 4× H200 141GB     |
| RAM         | 64GB                       | 128GB                       | 1TB+                             |
| Disco       | NVMe de 200GB              | NVMe de 600GB               | NVMe de 4TB                      |
| CUDA        | 12.4+                      | 12.6+                       | 12.6+                            |
| Red         | —                          | —                           | NVLink / 400Gb IB para multinodo |

**Elección de Clore.ai:** Para el 95% de los usuarios, **V4-Flash en una sola A100 80GB en FP8** es el punto ideal — contexto completo de 256K, sin pérdida por cuantización, \~$5–7/día en el marketplace. Apunta a [H100](https://clore.ai/rent-h100.html) o [H200](https://clore.ai/rent-h200.html) configuraciones tensor-parallel solo cuando realmente necesites el contexto de 1M de V4-Pro o el margen extra de razonamiento.

***

## Opción A — Ollama / GGUF (cuantizado, solo V4-Flash)

Unsloth publicó cuantizaciones GGUF para V4-Flash dentro de las 48 horas posteriores al lanzamiento. Q4\_K\_M es el punto ideal — cabe en 1× 80GB o 2× 48GB y mantiene la calidad cerca de FP8.

```bash
# Descargar el build Q4_K_M de Unsloth
docker exec ollama ollama pull hf.co/unsloth/DeepSeek-V4-Flash-GGUF:Q4_K_M
docker exec ollama ollama run hf.co/unsloth/DeepSeek-V4-Flash-GGUF:Q4_K_M

# O con llama.cpp directamente sobre un GGUF descargado
docker run --gpus all -it --rm -p 8080:8080 \
  -v $(pwd)/models:/models \
  ghcr.io/ggerganov/llama.cpp:server-cuda \
  -m /models/DeepSeek-V4-Flash-Q4_K_M.gguf \
  --n-gpu-layers 99 --ctx-size 65536 \
  --port 8080 --host 0.0.0.0
```

{% hint style="info" %}
Las cuantizaciones GGUF para V4-**nivel Pro** existen pero no son prácticas — incluso Q2\_K ocupa \~400GB y el rendimiento de offload es inutilizable para chat. Quédate con Flash para despliegues cuantizados.
{% endhint %}

***

## Opción B — vLLM (API de producción, recomendada)

vLLM 0.7.x añadió soporte desde el día 0 para ambos checkpoints V4. Los kernels de atención híbrida necesitan `--trust-remote-code` y hardware Hopper o Blackwell para alcanzar la velocidad máxima.

**V4-Flash en una sola H100 / A100 80GB:**

```yaml
version: "3.8"
services:
  vllm:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - hf_cache:/root/.cache/huggingface
    command: >
      --model deepseek-ai/DeepSeek-V4-Flash
      --tensor-parallel-size 1
      --max-model-len 131072
      --dtype bfloat16
      --gpu-memory-utilization 0.92
      --enable-chunked-prefill
      --served-model-name deepseek-v4-flash
      --trust-remote-code
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    shm_size: "16gb"

volumes:
  hf_cache:
```

**V4-Pro en 8× H100 80GB:** sustituye el comando por:

```yaml
    command: >
      --model deepseek-ai/DeepSeek-V4-Pro
      --tensor-parallel-size 8
      --max-model-len 262144
      --dtype bfloat16
      --gpu-memory-utilization 0.90
      --enable-chunked-prefill
      --enable-prefix-caching
      --served-model-name deepseek-v4-pro
      --trust-remote-code
```

```bash
# Probar la API
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash",
    "messages": [{"role": "user", "content": "Escribe un servidor TCP echo async en Rust con apagado ordenado."}],
    "max_tokens": 2048,
    "temperature": 0.6
  }'
```

{% hint style="info" %}
Empieza con `--max-model-len 131072` aunque al final quieras el contexto completo de 1M — los contextos largos aumentan drásticamente el tiempo de prefill y la memoria KV. Súbelo solo cuando la base sea estable.
{% endhint %}

***

## Opción C — SGLang (alternativa, a menudo más rápida en Hopper)

RadixAttention y el prefix caching de SGLang encajan bien con la atención híbrida de V4 — para cargas de trabajo agenticas con prompts compartidos, espera un tok/s notablemente mejor que en vLLM.

```bash
docker pull lmsysorg/sglang:latest

# V4-Flash en 1× H100/A100
python3 -m sglang.launch_server \
  --model-path deepseek-ai/DeepSeek-V4-Flash \
  --tp-size 1 \
  --context-length 131072 \
  --mem-fraction-static 0.90 \
  --enable-torch-compile \
  --served-model-name deepseek-v4-flash \
  --trust-remote-code

# V4-Pro en 8× H100
python3 -m sglang.launch_server \
  --model-path deepseek-ai/DeepSeek-V4-Pro \
  --tp-size 8 \
  --context-length 262144 \
  --mem-fraction-static 0.88 \
  --enable-torch-compile \
  --served-model-name deepseek-v4-pro \
  --trust-remote-code
```

De SGLang `--enable-torch-compile` normalmente añade otro 10–20% de rendimiento en Hopper después del calentamiento inicial.

***

## Recomendaciones de GPU en Clore.ai

| Configuración                                              | Modelo                              | VRAM       | Rendimiento esperado                        | Coste en Clore.ai |
| ---------------------------------------------------------- | ----------------------------------- | ---------- | ------------------------------------------- | ----------------- |
| 2× [RTX 4090](https://clore.ai/rent-4090.html) (Q4 GGUF)   | V4-Flash                            | 48GB       | Uso hobby, un solo flujo                    | \~$2–3/día        |
| 1× [A100 80GB](https://clore.ai/rent-a100-80gb.html) (FP8) | V4-Flash                            | 80GB       | Producción sólida, inquilino único          | \~$5–7/día        |
| 1× RTX 5090 32GB (Q4 GGUF, descarga parcial)               | V4-Flash                            | 32GB + RAM | Limitado, solo desarrollo                   | \~$3.94/h pico    |
| 4× [H100 80GB](https://clore.ai/rent-h100.html)            | V4-Flash FP8 (excesivo) o V4-Pro Q4 | 320GB      | Flash multiinquilino, Pro de un solo flujo  | \~$24–32/día      |
| 8× [H100 80GB](https://clore.ai/rent-h100.html)            | V4-Pro BF16                         | 640GB      | Inferencia de frontera en producción        | \~$48–64/día      |
| 4× [H200 141GB](https://clore.ai/rent-h200.html)           | V4-Pro BF16 + contexto de 1M        | 564GB      | Contexto completo de 1M, rendimiento máximo | \~$32–48/día      |

{% hint style="success" %}
**Mejor valor en Clore.ai:** 1× A100 80GB ejecutando V4-Flash FP8. Obtienes contexto de 256K, costo de inferencia de \~13B activos, sin pérdida por cuantización, y la factura es aproximadamente el precio de una suscripción a la API de Claude Sonnet — con pesos que permanecen en tu propia máquina.
{% endhint %}

***

## Casos de uso

* **Razonamiento sobre bases de código completas** — el contexto de 1M de V4-Pro cabe en un monorepo típico de 500K LOC más sus pruebas en un solo prompt
* **RAG de formato largo** — mete libros completos, escritos judiciales o informes anuales en el contexto, sin pasar por la canalización de fragmentación
* **Codificación agentica** — V4-Flash iguala a V3 en SWE-Bench a una fracción del costo de inferencia; combínalo con SWE-agent u OpenHands
* **Síntesis de múltiples documentos** — flujos de trabajo de investigación que antes requerían Gemini 2.5 Pro ahora se ejecutan en tu propio hardware
* **Sustituto autohospedado de Cursor / Copilot** — V4-Flash en una sola A100 satisface a un equipo de 5 desarrolladores
* **Base para fine-tuning** — la licencia MIT + la arquitectura MoE limpia lo convierten en un punto de partida sólido para fine-tunes de dominio

***

## Benchmarks

{% hint style="warning" %}
**Afirmado por el proveedor — verificar de forma independiente.** Los números de abajo provienen del anuncio de DeepSeek del 22 de abril de 2026 y de la tarjeta del modelo. Todavía se están publicando reproducciones independientes; tómalo como orientativo, no como verdad absoluta.
{% endhint %}

| Benchmark                                   | V4-Pro | V4-Flash | DeepSeek V3 | GLM-5.1 |
| ------------------------------------------- | ------ | -------- | ----------- | ------- |
| MMLU-Pro                                    | \~84%  | \~78%    | \~76%       | \~80%   |
| SWE-Bench Verified                          | \~82%  | \~74%    | \~70%       | \~79%   |
| HumanEval                                   | \~96%  | \~92%    | \~91%       | \~94%   |
| MATH-500                                    | \~94%  | \~88%    | \~85%       | \~90%   |
| LiveCodeBench                               | \~76%  | \~68%    | \~62%       | \~72%   |
| Contexto largo (needle-in-a-haystack de 1M) | \~98%  | n/d      | n/d         | n/d     |

Para una comparación de pesos abiertos de manzanas con manzanas, consulta la [guía de GLM-5.1](/guides/guides_v2-es/modelos-de-lenguaje/glm-5-1.md) — V4-Pro y GLM-5.1 se reparten los golpes según el benchmark.

***

## Solución de problemas

| Problema                                     | Solución                                                                                                                                                                                                  |
| -------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` cargando V4-Pro en 8×H100 | BF16 necesita \~3,2TB — no puedes meter Pro en un solo nodo 8×H100. Usa 4× H200 141GB o multinodo.                                                                                                        |
| `backend de atención no compatible`          | V4 necesita vLLM ≥ 0.7.0 o SGLang ≥ 0.4.4. Ejecuta `pip install -U vllm` (o descarga la `:latest` imagen de Docker).                                                                                      |
| Descarga lenta de HuggingFace                | Usa `huggingface-cli download deepseek-ai/DeepSeek-V4-Flash --local-dir ./weights --resume-download`. Pro ocupa \~3,2TB; Flash ocupa \~570GB.                                                             |
| `--trust-remote-code` rechazado              | Los módulos de atención híbrida se entregan como código personalizado en el repositorio — `--trust-remote-code` se requiere para ambos motores hasta que los kernels lleguen a Transformers upstream.     |
| GGUF Q4 produce texto incoherente            | Asegúrate de usar el build de Unsloth (`unsloth/DeepSeek-V4-Flash-GGUF`), no una cuantización comunitaria temprana. El router MoE necesita un manejo especial que las primeras cuantizaciones hacían mal. |
| OOM de contexto de 1M en V4-Pro              | Reduce a `--max-model-len 262144` y añade `--enable-prefix-caching`. Servir 1M real necesita H200 o B200.                                                                                                 |
| Prefill lento en contexto largo              | Esto es esperado — incluso con atención híbrida, un prefill de 500K+ tarda minutos, no segundos. Usa `--enable-chunked-prefill` y prefix caching para amortizar.                                          |

***

## Siguientes pasos

* **Predecesor:** [DeepSeek V3](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-v3.md) — el modelo que V4-Flash reemplaza efectivamente
* **Hermano de razonamiento:** [DeepSeek-R1](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-r1.md) — afinado para chain-of-thought, sigue siendo útil para flujos de trabajo con mucho matemáticas
* **Alternativa de pesos abiertos:** [GLM-5.1](/guides/guides_v2-es/modelos-de-lenguaje/glm-5-1.md) — MoE de 744B, a la cabeza de SWE-Bench Pro, relación precio-rendimiento comparable
* **Alternativa multimodal:** [Qwen3.5-Omni](/guides/guides_v2-es/modelos-de-lenguaje/qwen35-omni.md) — si necesitas visión/audio en el mismo modelo
* **Alquila el hardware:** [Marketplace de Clore.ai](https://clore.ai/marketplace) — H100/H200/A100/RTX 4090 desde $0.50/día

### Enlaces

* [DeepSeek-V4-Pro en HuggingFace](https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro)
* [DeepSeek-V4-Flash en HuggingFace](https://huggingface.co/deepseek-ai/DeepSeek-V4-Flash)
* [Cuantizaciones GGUF V4-Flash de Unsloth](https://huggingface.co/unsloth/DeepSeek-V4-Flash-GGUF)
* [GitHub de DeepSeek](https://github.com/deepseek-ai)
* [Documentación de vLLM](https://docs.vllm.ai)
* [Repositorio de SGLang](https://github.com/sgl-project/sglang)


---

# 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/deepseek-v4.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.
