# DeepSeek-V3

Ejecute DeepSeek-V3, el LLM de código abierto de última generación con capacidades excepcionales de razonamiento en GPUs de CLORE.AI.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
**Actualizado: DeepSeek-V3-0324 (marzo de 2024)** — La última revisión de DeepSeek-V3 trae mejoras significativas en generación de código, razonamiento matemático y resolución general de problemas. Vea el [registro de cambios](#whats-new-in-deepseek-v3-0324) para más detalles.
{% endhint %}

## ¿Por qué DeepSeek-V3?

* **Última generación** - Compite con GPT-4o y Claude 3.5 Sonnet
* **671B MoE** - 671B parámetros totales, 37B activos por token (inferencia eficiente)
* **Razonamiento mejorado** - DeepSeek-V3-0324 es significativamente mejor en matemáticas y código
* **Eficiente** - La arquitectura MoE reduce los costos de cómputo frente a modelos densos
* **Código abierto** - Pesos completamente abiertos bajo licencia MIT
* **Contexto largo** - Ventana de contexto de 128K tokens

## Novedades en DeepSeek-V3-0324

DeepSeek-V3-0324 (revisión de marzo de 2024) introduce mejoras significativas en dominios clave:

### Generación de código

* **+8-12% en HumanEval** comparado con el V3 original
* Mejor en bases de código multiarchivo y tareas complejas de refactorización
* Mejor comprensión de frameworks modernos (FastAPI, Pydantic v2, LangChain v0.3)
* Más fiable al generar código completo y ejecutable sin omisiones

### Razonamiento matemático

* **+5% en MATH-500** benchmark
* Mejor construcción paso a paso de demostraciones
* Mayor precisión numérica para problemas de múltiples pasos
* Mayor capacidad para identificar y corregir errores a mitad de la solución

### Razonamiento general

* Mayor deducción lógica e inferencia causal
* Mejor en tareas de planificación multi-paso
* Rendimiento más consistente en casos límite y prompts ambiguos
* Mejora en el seguimiento de instrucciones en solicitudes complejas con múltiples restricciones

## Despliegue rápido en CLORE.AI

**Imagen Docker:**

```
vllm/vllm-openai:latest
```

**Puertos:**

```
22/tcp
8000/http
```

**Comando (Se requieren múltiples GPUs):**

```bash
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3-0324 \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 8 \
    --trust-remote-code
```

## Accediendo a tu servicio

Después del despliegue, encuentra tu `http_pub` URL en **Mis Pedidos**:

1. Ir a **Mis Pedidos** página
2. Haz clic en tu pedido
3. Encuentra la `http_pub` URL (por ejemplo, `abc123.clorecloud.net`)

Usa `https://TU_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos abajo.

### Verificar que funciona

```bash
# Comprobar si el servicio está listo
curl https://your-http-pub.clorecloud.net/health

# Listar modelos disponibles
curl https://your-http-pub.clorecloud.net/v1/models

# Obtener versión
curl https://your-http-pub.clorecloud.net/version
```

{% hint style="warning" %}
**Importante:** DeepSeek-V3 requiere **8x A100 80GB** GPUs y un tiempo de descarga significativo. El HTTP 502 puede persistir durante 15-30 minutos mientras se descarga el modelo.
{% endhint %}

## Variantes de modelo

| Modelo            | Parámetros | Activo | VRAM requerida | HuggingFace                                                                                             |
| ----------------- | ---------- | ------ | -------------- | ------------------------------------------------------------------------------------------------------- |
| DeepSeek-V3-0324  | 671B       | 37B    | 8x80GB         | [deepseek-ai/DeepSeek-V3-0324](https://huggingface.co/deepseek-ai/DeepSeek-V3-0324)                     |
| DeepSeek-V3       | 671B       | 37B    | 8x80GB         | [deepseek-ai/DeepSeek-V3](https://huggingface.co/deepseek-ai/DeepSeek-V3)                               |
| DeepSeek-V3-Base  | 671B       | 37B    | 8x80GB         | [deepseek-ai/DeepSeek-V3-Base](https://huggingface.co/deepseek-ai/DeepSeek-V3-Base)                     |
| DeepSeek-V2.5     | 236B       | 21B    | 4x80GB         | [deepseek-ai/DeepSeek-V2.5](https://huggingface.co/deepseek-ai/DeepSeek-V2.5)                           |
| DeepSeek-V2-Lite  | 16B        | 2.4B   | 16GB           | [deepseek-ai/DeepSeek-V2-Lite](https://huggingface.co/deepseek-ai/DeepSeek-V2-Lite)                     |
| DeepSeek-Coder-V2 | 236B       | 21B    | 4x80GB         | [deepseek-ai/DeepSeek-Coder-V2-Instruct](https://huggingface.co/deepseek-ai/DeepSeek-Coder-V2-Instruct) |

## Requisitos de hardware

### Precisión completa

| Modelo           | Mínimo        | Recomendado  |
| ---------------- | ------------- | ------------ |
| DeepSeek-V3-0324 | 8x A100 80GB  | 8x H100 80GB |
| DeepSeek-V2.5    | 4x A100 80GB  | 4x H100 80GB |
| DeepSeek-V2-Lite | RTX 4090 24GB | A100 40GB    |

### Cuantizado (AWQ/GPTQ)

| Modelo           | Cuantización | VRAM   |
| ---------------- | ------------ | ------ |
| DeepSeek-V3-0324 | INT4         | 4x80GB |
| DeepSeek-V2.5    | INT4         | 2x80GB |
| DeepSeek-V2-Lite | INT4         | 8GB    |

## Instalación

### Usando vLLM (Recomendado)

```bash
pip install vllm==0.7.3

# DeepSeek-V3-0324 (último, 8 GPUs)
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3-0324 \
    --tensor-parallel-size 8 \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000

# V3 original (todavía disponible)
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3 \
    --tensor-parallel-size 8 \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000
```

### Usando Transformers

```python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "deepseek-ai/DeepSeek-V3-0324"

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

messages = [{"role": "user", "content": "Explica la computación cuántica en términos sencillos."}]
inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)

outputs = model.generate(inputs, max_new_tokens=512, temperature=0.7)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

### Usando Ollama

```bash
# Descargar DeepSeek-V3 (requiere recursos significativos)
ollama pull deepseek-v3

# O variante más ligera
ollama pull deepseek-coder-v2:16b

# Ejecutar
ollama run deepseek-v3
```

## Uso de la API

### API compatible con OpenAI (vLLM)

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="no-necesaria"
)

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[
        {"role": "system", "content": "Eres un asistente de IA servicial."},
        {"role": "user", "content": "Escribe una función en Python para encontrar números primos."}
    ],
    temperature=0.7,
    max_tokens=1000
)

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

### Streaming

```python
stream = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": "Explica el aprendizaje automático"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
```

### cURL

```bash
curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "deepseek-ai/DeepSeek-V3-0324",
        "messages": [
            {"role": "user", "content": "¿Cuál es la capital de Francia?"}
        ],
        "temperature": 0.7
    }'
```

## DeepSeek-V2-Lite (GPU única)

Para usuarios con hardware limitado:

```bash
# Usando vLLM
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V2-Lite \
    --trust-remote-code \
    --host 0.0.0.0

# Usando Ollama
ollama run deepseek-coder-v2:16b
```

```python
# Usando Transformers en GPU única
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model = AutoModelForCausalLM.from_pretrained(
    "deepseek-ai/DeepSeek-V2-Lite",
    torch_dtype=torch.float16,
    device_map="cuda",
    trust_remote_code=True
)
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-V2-Lite", trust_remote_code=True)
```

## Generación de código

DeepSeek-V3-0324 es de primera clase para código:

```python
prompt = """Escribe una clase en Python para un árbol binario de búsqueda con:
- insertar
- buscar
- eliminar
- recorrido en orden
Incluye anotaciones de tipo y docstrings."""

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.2  # Menor para código
)

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

Tareas avanzadas de código donde V3-0324 destaca:

```python
# Refactorización multiarchivo
prompt = """Tengo una aplicación Flask con todo el código en app.py (500 líneas).
Refactorízala para usar el patrón application factory con blueprints para:
- auth (login, register, logout)
- api (endpoints REST)
- admin (panel de control)
Muestra la estructura completa de archivos y todos los archivos."""

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1,
    max_tokens=4000
)
```

## Matemáticas y razonamiento

```python
# Problema matemático complejo
prompt = """Demuestra que para cualquier entero n >= 1, la suma 1^2 + 2^2 + ... + n^2 = n(n+1)(2n+1)/6.
Usa inducción matemática y muestra todos los pasos claramente."""

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1  # Muy baja para matemáticas
)

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

## Configuración multi-GPU

### 8x GPU (Modelo completo — V3-0324)

```bash
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3-0324 \
    --tensor-parallel-size 8 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.9 \
    --trust-remote-code
```

### 4x GPU (V2.5)

```bash
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V2.5 \
    --tensor-parallel-size 4 \
    --max-model-len 16384 \
    --trust-remote-code
```

## Rendimiento

### Rendimiento (tokens/seg)

| Modelo                | GPUs         | Contexto | Tokens/seg |
| --------------------- | ------------ | -------- | ---------- |
| DeepSeek-V3-0324      | 8x H100      | 32K      | \~85       |
| DeepSeek-V3-0324      | 8x A100 80GB | 32K      | \~52       |
| DeepSeek-V3-0324 INT4 | 4x A100 80GB | 16K      | \~38       |
| DeepSeek-V2.5         | 4x A100 80GB | 16K      | \~70       |
| DeepSeek-V2.5         | 2x A100 80GB | 8K       | \~45       |
| DeepSeek-V2-Lite      | RTX 4090     | 8K       | \~40       |
| DeepSeek-V2-Lite      | RTX 3090     | 4K       | \~25       |

### Tiempo hasta el primer token (TTFT)

| Modelo           | Configuración | TTFT     |
| ---------------- | ------------- | -------- |
| DeepSeek-V3-0324 | 8x H100       | \~750ms  |
| DeepSeek-V3-0324 | 8x A100       | \~1100ms |
| DeepSeek-V2.5    | 4x A100       | \~500ms  |
| DeepSeek-V2-Lite | RTX 4090      | \~150ms  |

### Uso de memoria

| Modelo           | Precisión | VRAM requerida |
| ---------------- | --------- | -------------- |
| DeepSeek-V3-0324 | FP16      | 8x 80GB        |
| DeepSeek-V3-0324 | INT4      | 4x 80GB        |
| DeepSeek-V2.5    | FP16      | 4x 80GB        |
| DeepSeek-V2.5    | INT4      | 2x 80GB        |
| DeepSeek-V2-Lite | FP16      | 20GB           |
| DeepSeek-V2-Lite | INT4      | 10GB           |

## Benchmarks

### DeepSeek-V3-0324 vs Competencia

| Benchmark                   | V3-0324 | V3 (original) | GPT-4o | Claude 3.5 Sonnet |
| --------------------------- | ------- | ------------- | ------ | ----------------- |
| MMLU                        | 88.5%   | 87.1%         | 88.7%  | 88.3%             |
| HumanEval                   | 90.2%   | 82.6%         | 90.2%  | 92.0%             |
| MATH-500                    | 67.1%   | 61.6%         | 76.6%  | 71.1%             |
| GSM8K                       | 92.1%   | 89.3%         | 95.8%  | 96.4%             |
| LiveCodeBench               | 72.4%   | 65.9%         | 71.3%  | 73.8%             |
| Clasificación en Codeforces | 1850    | 1720          | 1780   | 1790              |

*Nota: la mejora en MATH-500 de V3 → V3-0324 es de +5.5 puntos porcentuales.*

## Docker Compose

```yaml
versión: '3.8'

services:
  deepseek:
    imagen: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}
    comando: >
      --model deepseek-ai/DeepSeek-V2-Lite
      --host 0.0.0.0
      --port 8000
      --trust-remote-code
      --gpu-memory-utilization 0.9
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
```

## Resumen de requisitos de GPU

| Caso de uso               | Configuración recomendada | Costo/Hora |
| ------------------------- | ------------------------- | ---------- |
| DeepSeek-V3-0324 completo | 8x A100 80GB              | \~$2.00    |
| DeepSeek-V2.5             | 4x A100 80GB              | \~$1.00    |
| Desarrollo/Pruebas        | RTX 4090 (V2-Lite)        | \~$0.10    |
| API de producción         | 8x H100 80GB              | \~$3.00    |

## Estimación de costos

Tarifas típicas del mercado de CLORE.AI:

| Configuración de GPU | Tarifa por hora | Tarifa diaria |
| -------------------- | --------------- | ------------- |
| RTX 4090 24GB        | \~$0.10         | \~$2.30       |
| A100 40GB            | \~$0.17         | \~$4.00       |
| A100 80GB            | \~$0.25         | \~$6.00       |
| 4x A100 80GB         | \~$1.00         | \~$24.00      |
| 8x A100 80GB         | \~$2.00         | \~$48.00      |

*Los precios varían según el proveedor. Consulta* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *para las tarifas actuales.*

**Ahorra dinero:**

* Usa **Spot** mercado para desarrollo (a menudo 30-50% más barato)
* Paga con **CLORE** tokens
* Use DeepSeek-V2-Lite para pruebas antes de escalar

## Solución de problemas

### Memoria insuficiente

```bash
# Reducir la longitud de contexto
--max-model-len 8192

# O usar cuantización
--quantization awq

# Para V2-Lite en GPU de 12GB
--gpu-memory-utilization 0.85
--max-model-len 4096
```

### Descarga lenta del modelo

```bash
# Pre-descarga
huggingface-cli download deepseek-ai/DeepSeek-V3-0324

# O use un espejo
export HF_ENDPOINT=https://hf-mirror.com
```

### Error trust\_remote\_code

```bash
# Incluya siempre este flag para modelos DeepSeek
--trust-remote-code
```

### Multi-GPU no funciona

```bash
# Verifique NCCL
nvidia-smi topo -m

# Establecer variables NCCL
export NCCL_DEBUG=INFO
export NCCL_P2P_DISABLE=0
```

## DeepSeek vs Otros

| Función     | DeepSeek-V3-0324   | Llama 3.1 405B | Mixtral 8x22B      |
| ----------- | ------------------ | -------------- | ------------------ |
| Parámetros  | 671B (37B activos) | 405B           | 176B (44B activos) |
| Contexto    | 128K               | 128K           | 64K                |
| Código      | **Excelente**      | Genial         | Bueno              |
| Matemáticas | **Excelente**      | Bueno          | Bueno              |
| VRAM mínima | 8x80GB             | 8x80GB         | 2x80GB             |
| Licencia    | MIT                | Llama 3.1      | Apache 2.0         |

**Use DeepSeek-V3 cuando:**

* Se necesite el mejor rendimiento en razonamiento
* La generación de código sea el uso principal
* Las tareas de matemáticas/lógica sean importantes
* Disponga de una configuración multi-GPU
* Desee pesos totalmente de código abierto (licencia MIT)

## Próximos pasos

* [vLLM](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) - Servidor de despliegue
* [DeepSeek-R1](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-r1.md) - Variante especializada en razonamiento
* [DeepSeek Coder](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-coder.md) - Variante específica para código
* [Ollama](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) - Despliegue más sencillo
* [Ajustar LLM](/guides/guides_v2-es/entrenamiento/finetune-llm.md) - Entrenamiento personalizado


---

# 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-v3.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.