Cómo ejecutar DeepSeek V4 localmente

TR

La forma práctica de ejecutar DeepSeek V4 en local es usar los pesos oficiales de código abierto con una pila de serving de alto rendimiento como vLLM y exponer el modelo mediante un endpoint local compatible con OpenAI. Los materiales públicos actuales de DeepSeek describen dos modelos en la familia V4: DeepSeek-V4-Pro con 1,6T de parámetros totales / 49B activos, y DeepSeek-V4-Flash con 284B totales / 13B activos, ambos con contexto de 1M de tokens y tres modos de razonamiento. Los ejemplos de despliegue local actuales de vLLM apuntan a 8× B200/B300 para Pro y 4× B200/B300 para Flash. Si no dispone de ese tipo de hardware, una alternativa alojada como CometAPI es el camino más práctico.

DeepSeek AI causó un gran impacto el 24 de abril de 2026 con el lanzamiento en vista previa de DeepSeek-V4, que presenta dos potentes modelos Mixture-of-Experts (MoE): DeepSeek-V4-Pro (1,6T de parámetros totales, 49B activos) y DeepSeek-V4-Flash (284B totales, 13B activos). Ambos admiten de forma nativa una ventana de contexto de 1 millón de tokens, un cambio de juego para el análisis de documentos largos, flujos de trabajo agénticos, programación sobre bases de código masivas y generación aumentada con recuperación (RAG) a escala.

Entrenado con más de 32 billones de tokens y con innovaciones arquitectónicas como Atención Dispersa Comprimida híbrida (CSA) + Atención Fuertemente Comprimida (HCA), hiperconexiones restringidas por variedades (mHC) y gestión eficiente de memoria, V4 logra hasta un 73% de reducción en FLOPs de inferencia y un 90% de reducción en la huella de la caché KV para contextos de 1M comparado con V3.2. Su rendimiento rivaliza con modelos cerrados de primer nivel, manteniendo pesos abiertos (licencia MIT) y resultando extremadamente rentable vía API.

Ejecutar estos modelos en local ofrece privacidad sin igual, cero costes recurrentes de API (más allá del hardware), capacidad offline y personalización completa. Sin embargo, su escala presenta desafíos: los pesos completos de V4-Pro superan los 800 GB de descarga y la inferencia exige hardware significativo o cuantización agresiva.

¿DeepSeek V4 realmente puede ejecutarse localmente?

Sí, pero “en local” aquí significa algo muy distinto a ejecutar un modelo de 7B en un portátil. Los materiales de DeepSeek y la nota de soporte de vLLM apuntan a sistemas grandes multi‑GPU: V4-Pro es un modelo de 1,6T de parámetros con 49B de parámetros activos, mientras que V4-Flash tiene 284B totales / 13B activos. Los ejemplos oficiales de despliegue de vLLM están escritos para 8× B200/B300 en Pro y 4× B200/B300 en Flash. Esa es la señal práctica más clara de que DeepSeek V4 es un despliegue local de clase empresarial, no un experimento casual de escritorio.

Hay una razón para esa escala. DeepSeek afirma que V4 admite una ventana de contexto de 1M de tokens, y el informe técnico indica que V4-Pro usa solo el 27% de los FLOPs de inferencia por token y 10% de la caché KV comparado con DeepSeek‑V3.2 a 1M de contexto. vLLM explica además que, con caché KV bf16, DeepSeek V4 usa 9,62 GiB de caché KV por secuencia a 1M de contexto, aproximadamente 8,7× menos que los 83,9 GiB estimados para una pila estilo DeepSeek‑V3.2 comparable. En otras palabras, V4 es dramáticamente más eficiente que generaciones anteriores, pero un millón de tokens sigue siendo un problema de sistemas enorme.

Tabla de comparación de arquitectura: DeepSeek V4 vs V3 y competidores

El diseño MoE de V4 activa solo una fracción de los parámetros por token, manteniendo el cómputo más cerca de un modelo denso de 13B–49B, a la vez que se beneficia del conocimiento de una red mucho mayor.

¿Qué modelo DeepSeek V4 debería usar?

Para la mayoría de despliegues locales, DeepSeek‑V4‑Flash es el mejor punto de partida. V4‑Flash ofrece un razonamiento que se acerca mucho a Pro en tareas agénticas más simples, siendo además más rápido y económico.

Use DeepSeek‑V4‑Pro cuando le importe más la capacidad absoluta que la eficiencia. Pro es el modelo más fuerte para razonamiento, programación y tareas agénticas más difíciles. Las tablas de benchmarks lo muestran: en la comparación oficial, V4‑Pro‑Base alcanza 90.1 en MMLU, 76.8 en HumanEval y 51.5 en LongBench‑V2, mientras que V4‑Flash‑Base obtiene 88.7, 69.5 y 44.7 respectivamente. Ambos son fuertes; Pro simplemente llega más alto cuando necesita el mejor resultado posible.

Una lectura simple de la tabla basta para la planificación de producto. Flash no es un modelo recortado; es un asistente de contexto largo serio con menor coste. Pro es el modelo a probar primero cuando el problema es difícil, con estado o cercano a un flujo de trabajo de conocimiento de producción.

Pila local recomendada

1) vLLM para serving de estilo producción

La opción oficial más sólida hoy es vLLM. El equipo de vLLM afirma que ahora admite la familia DeepSeek V4 y proporciona comandos concretos de lanzamiento de un solo nodo para ambos modelos. Su publicación enmarca a V4 como una familia de contexto largo diseñada para tareas de hasta un millón de tokens y describe el trabajo de implementación necesario para caché KV híbrida, fusión de kernels y serving desagregado.

Para V4‑Pro, el ejemplo de vLLM apunta a 8× B200 o 8× B300. Para V4‑Flash, el ejemplo apunta a 4× B200 o 4× B300. Los comandos también usan --kv-cache-dtype fp8, --block-size 256, --enable-expert-parallel y flags de parseo específicos de DeepSeek como --tokenizer-mode deepseek_v4, --tool-call-parser deepseek_v4 y --reasoning-parser deepseek_v4. Esa combinación es una pista muy fuerte de cómo DeepSeek espera que se haga el autoalojamiento serio.

# DeepSeek-V4-Flash on a supported multi-GPU hostdocker run --gpus all \  --ipc=host -p 8000:8000 \  -v ~/.cache/huggingface:/root/.cache/huggingface \  vllm/vllm-openai:deepseekv4-cu130 deepseek-ai/DeepSeek-V4-Flash \  --trust-remote-code \  --kv-cache-dtype fp8 \  --block-size 256 \  --enable-expert-parallel \  --data-parallel-size 4 \  --compilation-config '{"cudagraph_mode":"FULL_AND_PIECEWISE", "custom_ops":["all"]}' \  --attention_config.use_fp4_indexer_cache=True \  --tokenizer-mode deepseek_v4 \  --tool-call-parser deepseek_v4 \  --enable-auto-tool-choice \  --reasoning-parser deepseek_v4

Para cambiar a V4‑Pro, mantenga el mismo patrón y cambie el modelo a deepseek-ai/DeepSeek-V4-Pro, con el tamaño de paralelismo de datos ajustado al ejemplo de Pro en la publicación de vLLM. Esa es la manera más simple de comenzar a probar en local sin reinventar la pila de serving.

2) Auxiliares de inferencia del repositorio de DeepSeek

DeepSeek V4 no incluye una plantilla de chat en formato Jinja. En su lugar, proporciona una carpeta encoding con scripts de Python y casos de prueba para convertir mensajes estilo OpenAI en cadenas de entrada del modelo y parsear la salida. La misma página dice consultar la carpeta inference para detalles de despliegue local, incluida la conversión de pesos y demos de chat interactivas. Es útil si quiere construir un front‑end personalizado o controlar de cerca el formateo del prompt.

3) CometAPI como plan de respaldo práctico

Si no dispone de hardware clase B200/B300, una ruta alojada es la opción sensata. CometAPI afirma ofrecer una API key para todo, acceso a 500+ modelos de IA y precios 20–40% más baratos que las tarifas de proveedores oficiales. También publica páginas dedicadas a DeepSeek V4, incluidos DeepSeek‑V4‑Pro y DeepSeek‑V4‑Flash, con ejemplos de integración compatibles con OpenAI.

Paso a paso: cómo ejecutar DeepSeek V4 en local

1. Requisitos previos

• SO: Se prefiere Linux (Ubuntu 22.04/24.04) para mejor soporte de CUDA/ROCm. Windows vía WSL2 o nativo. macOS con Metal (limitado para los modelos más grandes).
• Drivers: NVIDIA CUDA 12.4+ (o la última). AMD ROCm para tarjetas Radeon.
• Python 3.11+, Git y espacio en disco suficiente.
• Cuenta de Hugging Face para modelos restringidos (si aplica): huggingface-cli login.

2. La manera más fácil: Ollama o LM Studio (para principiantes)

Ollama ofrece la experiencia de CLI y WebUI más simple. A finales de abril de 2026, el soporte completo de V4 puede requerir Modelfiles personalizados o etiquetas de la comunidad, pero las versiones cuantizadas de V4‑Flash están surgiendo rápidamente.

Instale Ollama (Linux/macOS):

curl -fsSL https://ollama.com/install.sh | sh
ollama --version

Ejecute un modelo compatible (comience con uno más pequeño o busque etiquetas de V4):

ollama pull deepseek-v4-flash:q4_0   # Ejemplo de etiqueta cuantizada; consulte ollama.com/library o la comunidad
ollama run deepseek-v4-flash:q4_0

Para personalizar: cree un Modelfile (texto):

FROM ./DeepSeek-V4-Flash-GGUF-Q4.gguf
TEMPLATE """{{ .Prompt }}"""
PARAMETER num_ctx 32768  # Comience de forma conservadora; aumente a medida que el hardware lo permita hasta 1M con suficiente RAM/VRAM

Luego ejecute: ollama create my-v4-flash -f Modelfile.

LM Studio: alternativa GUI. Descárguelo desde lmstudio.ai, busque/explore en HF cuantizaciones GGUF de DeepSeek‑V4 (estilo TheBloke u oficiales), cargue y chatee. Excelente para experimentar con deslizadores de contexto y descarga a GPU.

Open WebUI: Capa encima de Ollama para una interfaz tipo ChatGPT (Bash):

docker run -d -p 8080:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main

Acceda en http://localhost:8080.

3. Avanzado: Hugging Face + vLLM o SGLang (alto rendimiento)

Para máxima velocidad y soporte de contexto de 1M, use vLLM (excelente soporte MoE y PagedAttention):

Paso 1: Prepare el entorno

Comience instalando la pila actual de vLLM y asegúrese de que su CUDA, drivers y topología de GPU coinciden con el modelo que quiere ejecutar. recommending temperature = 1.0 and top_p = 1.0 for local deployment, and for Think Max it recommends a context window of at least 384K tokens. Eso es un punto de partida útil tanto si está construyendo una app de chat, un asistente de programación o un flujo agéntico.

Instalación:

Bash
pip install -U "vllm>=0.9.0"  # Check latest for V4 compatibility

Descargar el modelo (use CLI para archivos grandes):

Bash
pip install -U "huggingface_hub[cli]"
huggingface-cli download deepseek-ai/DeepSeek-V4-Flash --local-dir ./DeepSeek-V4-Flash

Servir con vLLM (ejemplo para Flash en 2 GPU):

Paso 2: Lance el servidor del modelo

Una vez que el contenedor esté arriba, exponga el modelo como un endpoint local compatible con OpenAI. Eso facilita reutilizar su código de aplicación existente y cambiar backends sin modificar la arquitectura de su app.

Servir con vLLM (ejemplo para Flash en 2 GPU):

Python
from vllm import LLM, SamplingParams

llm = LLM(
    model="deepseek-ai/DeepSeek-V4-Flash",
    tensor_parallel_size=2,      # Ajuste según el número de GPU
    max_model_len=1048576,       # Contexto de 1M (si el hardware lo permite)
    dtype="auto",                # o "fp8" / "bfloat16"
    quantization="gptq" if using quantized weights else None,
    gpu_memory_utilization=0.9
)

sampling_params = SamplingParams(temperature=0.7, top_p=0.95, max_tokens=4096)

outputs = llm.generate(["Explique en detalle la arquitectura de DeepSeek V4."], sampling_params)
for output in outputs:
    print(output.outputs[0].text)

Para modo servidor (API compatible con OpenAI):

Bash
vllm serve deepseek-ai/DeepSeek-V4-Flash \
  --tensor-parallel-size 2 \
  --max-model-len 1048576 \
  --port 8000

Luego realice consultas mediante el cliente de OpenAI configurando base_url="http://localhost:8000/v1".

SGLang alternativa para un rendimiento potencialmente mejor en contexto largo:

Bash
pip install "sglang[all]>=0.4.0"
python -m sglang.launch_server --model-path deepseek-ai/DeepSeek-V4-Flash --port 30000

Paso 3: Consulte el endpoint local desde Python

from openai import OpenAI
# Adjust the base URL if your vLLM server is bound differently.

client = OpenAI(
base_url="http://localhost:8000/v1",
api_key="EMPTY",
)

response = client.chat.completions.create(
model="deepseek-ai/DeepSeek-V4-Flash",
messages=[
{"role": "system", "content": "Eres un asistente técnico y preciso."},
{"role": "user", "content": "Explica la diferencia entre V4-Pro y V4-Flash."},
],
temperature=1.0,
top_p=1.0,
)

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

Expectativas de rendimiento y consejos de optimización

• Tokens/s: En una RTX 4090 con Flash Q4: 15–40+ t/s a 8K–32K de contexto (varía según implementación). Cae a 128K+ por atención/caché KV, pero las eficiencias de V4 ayudan. El escalado multi‑GPU es bueno con paralelismo tensorial/de pipeline.
• Optimizaciones:
• Use FlashAttention‑3 o PagedAttention de vLLM.
• Decodificación especulativa para un aumento de 1,5–2×.
• Técnicas de poda o compresión de contexto.
• Monitoree con nvidia-smi; utilice gpu_memory_utilization.
• Para CPU: llama.cpp con --n-gpu-layers -1 (todo descargado a GPU si es posible) o CPU pura con gran RAM.

Evalúe su configuración con herramientas como llama-bench o scripts simples de cronometraje. El rendimiento real depende de la longitud del prompt, la longitud de la generación y el hardware.

Desafíos y limitaciones del despliegue local de V4

• Intensidad de recursos: Incluso Flash requiere hardware decente para velocidades cómodas con contextos largos.
• Compromisos de cuantización: Menos bits pueden reducir la calidad de razonamiento, especialmente en tareas complejas; valide con benchmarks como SWE‑Bench, MMLU o sus evaluaciones específicas de dominio.
• Madurez del software: Al ser una vista previa (abril de 2026), el soporte totalmente optimizado en todos los backends está desplegándose. Revise issues de GitHub para vLLM, llama.cpp y HF.
• Descarga/almacenamiento: Modelos a escala de terabytes necesitan internet y almacenamiento rápidos.
• Consumo y calor: Las configuraciones de gama alta consumen mucha electricidad.

Para muchos usuarios, funcionan mejor los enfoques híbridos: ejecute tareas más pequeñas en local, y descargue a la nube el razonamiento pesado con contexto de 1M cuando sea necesario.

Cuando lo local no basta: integración fluida con CometAPI

Para muchos equipos, lo más inteligente no es forzar un despliegue local. Aunque el despliegue local destaca por la privacidad y el control, escalar a producción, manejar picos de carga o acceder al rendimiento completo sin cuantizar sin una inversión masiva en hardware suele inclinarse por una API confiable.

CometAPI proporciona una puerta de enlace unificada y compatible con OpenAI a los modelos DeepSeek, incluida la última serie Deeppseek V4, junto con docenas de otros LLMs (Claude, GPT, Llama, Qwen, Grok, etc.).

Dónde la API supera al despliegue local

Los modelos actuales de Deepseek V4 están disponibles mediante endpoints estilo OpenAI y estilo Anthropic, con URLs base que permanecen estables mientras cambia el nombre del modelo. Los docs también dicen que los nombres de modelo deepseek-chat y deepseek-reasoner eventualmente quedarán obsoletos y mapearán al comportamiento de V4‑Flash durante la transición.

Eso importa porque el despliegue local tiene coste operacional. Si la carga de trabajo no es sensible a la residencia de datos o si su equipo quiere un time‑to‑value más rápido, la ruta API suele ser la opción racional. V4‑Flash a $0.14 por 1M de tokens de entrada en cache miss, $0.0028 por 1M de tokens de entrada en cache hit, y $0.28 por 1M de tokens de salida. La misma página indica que V4‑Pro está actualmente descontado un 75% hasta el 31 de mayo de 2026, a $0.435 por 1M de tokens de entrada en cache miss y $0.87 por 1M de tokens de salida.

La mejor alternativa para DeepSeek: dónde encaja CometAPI

CometAPI es útil cuando el objetivo no es solo llamar una vez a DeepSeek V4, sino construir una pila que pueda cambiar de modelo rápidamente. CometAPI dice que proporciona una sola API key para 500+ modelos, una API compatible con OpenAI, analíticas de uso y precios más bajos que las tarifas oficiales de los proveedores. También se posiciona como una forma de evitar el vendor lock‑in y gestionar el gasto entre múltiples proveedores.

Eso convierte a CometAPI en una recomendación sólida para equipos que están evaluando V4‑Pro frente a V4‑Flash, o comparando DeepSeek con otros modelos frontera en la misma aplicación. En lugar de cablear una integración nueva cada vez que el modelo cambia, la aplicación puede mantener un cliente estilo OpenAI estable y cambiar solo el valor de model y la base URL. La guía de V4 de CometAPI muestra exactamente ese patrón.

Inicio rápido con CometAPI para DeepSeek V4:

• Use el SDK de OpenAI:
• Regístrese/inicie sesión en CometAPI.com.
• Genere una API key en la consola.

Aquí está la versión alojada del mismo patrón de integración:

from openai import OpenAIclient = OpenAI(    base_url="https://api.cometapi.com",    api_key="YOUR_COMETAPI_KEY",)response = client.chat.completions.create(    model="deepseek-v4-pro",    messages=[        {"role": "system", "content": "Eres un asistente sénior de programación."},        {"role": "user", "content": "Revisa esta arquitectura en busca de cuellos de botella."}    ],    stream=False,    extra_body={        "thinking": {"type": "enabled"},        "reasoning_effort": "high"    })print(response.choices[0].message.content)

El valor de esta ruta es operacional, no retórico. Elimina el trabajo de infraestructura, mantiene el código del cliente portable y da al equipo un lugar único para probar coste, latencia y calidad en varios modelos. CometAPI también dice que rastrea gasto, latencia y volumen de llamadas, algo útil cuando el prototipo pasa a carga de trabajo de producción.

Cuándo elegir local, API o CometAPI

La vía local se justifica cuando el control importa más que la conveniencia. La vía API se justifica cuando la velocidad y la simplicidad importan más que la propiedad. CometAPI es la capa intermedia cuando el equipo quiere portabilidad y control de costes sin rehacer la integración cada vez que cambia el modelo.

Preguntas frecuentes

¿Puede DeepSeek V4 ejecutarse en un portátil?

No en el sentido práctico que implican los tutoriales de inferencia local. Los materiales oficiales apuntan a despliegues multi‑GPU y multi‑nodo, y los tamaños de los modelos superan con mucho los presupuestos de memoria de consumo. Un portátil está bien para acceso por API, pero no para autoalojar de forma significativa V4‑Pro o siquiera un V4‑Flash cómodo.

¿Cuál es mejor: V4‑Pro o V4‑Flash?

V4‑Pro es el modelo más fuerte para razonamiento, programación e investigación. V4‑Flash es el mejor valor por defecto para velocidad, rendimiento y menor coste. La publicación oficial y la tabla de benchmarks apuntan a la misma conclusión.

¿CometAPI es obligatorio en el despliegue local?

No. Es una capa de producción opcional. La propia API de DeepSeek funciona directamente y el autoalojamiento local es posible mediante la ruta de inferencia oficial. CometAPI se vuelve atractivo cuando desea una sola vía de código para muchos proveedores de modelos, seguimiento de costes y un cambio más fácil entre familias de modelos.

Conclusión

DeepSeek V4 no es otro lanzamiento más. Es un sistema de contexto largo y enfoque agéntico con pesos abiertos, acceso vía API oficial y una división clara entre un modelo de razonamiento de alta gama y otro de menor coste orientado al rendimiento. Las últimas noticias oficiales importan porque cambian el árbol de decisión: el despliegue local es posible, pero solo para equipos con infraestructura GPU seria; el acceso por API está disponible de inmediato; y CometAPI es una recomendación sensata cuando la portabilidad y la disciplina de costes importan más que poseer la pila de inferencia.

Si la carga de trabajo es compleja y el hardware existe, comience con V4‑Pro. Si la carga es de volumen, comience con V4‑Flash. Si el objetivo es entregar rápido y mantener abiertas las opciones de modelo, use la capa API y mantenga su código portable. Esa es la estrategia de producción más defendible ahora mismo.

Próximos pasos accionables:

1. Evalúe su hardware y comience con V4‑Flash cuantizado mediante Ollama o LM Studio.
2. Experimente con los ejemplos de código anteriores y evalúe contra sus cargas de trabajo.
3. Explore cuantizaciones GGUF y optimizaciones de la comunidad a medida que maduren tras el lanzamiento.
4. Para producción o trabajo pesado, integre CometAPI para acceso confiable y rentable a V4‑Pro/Flash completo sin gestionar hardware.