> 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/deepseek-r1.md).

# Modelo de razonamiento DeepSeek-R1

Ejecuta el modelo de razonamiento de código abierto DeepSeek-R1 en GPUs de Clore.ai

{% hint style="success" %}
Todos los ejemplos se ejecutan en servidores GPU alquilados a través de la [Marketplace de CLORE.AI](https://clore.ai/marketplace). Las instancias RTX 4090 comienzan en $0.14–0.42/h.
{% endhint %}

## Descripción general

DeepSeek-R1 es un modelo de razonamiento de peso abierto de 671 mil millones de parámetros, lanzado en enero de 2025 por DeepSeek bajo la **Apache 2.0** licencia. Es el primer modelo abierto que iguala a OpenAI o1 en matemáticas, programación y pruebas científicas — mientras expone toda su cadena de pensamiento mediante `<think>` etiquetas.

El modelo completo usa **Mezcla de expertos (MoE)** con 37 mil millones de parámetros activos por token, lo que hace viable la inferencia a pesar del gran número total de parámetros. Para la mayoría de los practicantes, las **variantes destiladas** (1.5B → 70B) son más prácticas: heredan los patrones de razonamiento de R1 mediante destilación de conocimiento en las arquitecturas base Qwen-2.5 y Llama-3, y funcionan en GPUs de consumo.

## Características clave

* **Cadena de pensamiento explícita** — cada respuesta comienza con un `<think>` bloque en el que el modelo razona, retrocede y se autocorrige antes de producir una respuesta final
* **Entrenado con aprendizaje por refuerzo** — la capacidad de razonamiento surge de señales de recompensa de RL en lugar de datos de cadena de pensamiento escritos manualmente
* **Seis variantes destiladas** — modelos de 1.5B, 7B, 8B, 14B, 32B y 70B parámetros destilados del modelo completo de 671B en arquitecturas Qwen y Llama
* **licencia Apache 2.0** — totalmente comercial, sin regalías, sin restricciones de uso
* **Amplio soporte de frameworks** — Ollama, vLLM, llama.cpp, SGLang, Transformers y TGI funcionan de inmediato
* **AIME 2024 Pass\@1: 79.8%** — empata con OpenAI o1 en matemáticas de competición
* **Elo de Codeforces 2029** — supera los 1891 de o1 en programación competitiva

## Variantes del modelo

| Variante                   | Parámetros         | Arquitectura | VRAM FP16 | VRAM Q4  | Disco Q4 |
| -------------------------- | ------------------ | ------------ | --------- | -------- | -------- |
| DeepSeek-R1 (MoE completo) | 671B (37B activos) | DeepSeek MoE | \~1.3 TB  | \~350 GB | \~340 GB |
| R1-Distill-Llama-70B       | 70B                | Llama 3      | 140 GB    | 40 GB    | 42 GB    |
| R1-Distill-Qwen-32B        | 32B                | Qwen 2.5     | 64 GB     | 22 GB    | 20 GB    |
| R1-Distill-Qwen-14B        | 14B                | Qwen 2.5     | 28 GB     | 10 GB    | 9 GB     |
| R1-Distill-Llama-8B        | 8B                 | Llama 3      | 16 GB     | 6 GB     | 5.5 GB   |
| R1-Distill-Qwen-7B         | 7B                 | Qwen 2.5     | 14 GB     | 5 GB     | 4.5 GB   |
| R1-Distill-Qwen-1.5B       | 1.5B               | Qwen 2.5     | 3 GB      | 2 GB     | 1.2 GB   |

### Elegir una variante

| Caso de uso                                       | Variante recomendada   | GPU en Clore                                                                                                                  |
| ------------------------------------------------- | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| Experimentos rápidos, pruebas en el borde         | R1-Distill-Qwen-1.5B   | Cualquier GPU                                                                                                                 |
| Despliegue económico, inferencia rápida           | R1-Distill-Qwen-7B     | RTX 3090 ($0.07–0.21/hr)                                                                                                      |
| Punto ideal de producción con una sola GPU        | R1-Distill-Qwen-14B Q4 | [RTX 4090](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=deepseek-r1) ($0.14–0.42/hr)       |
| Mejor calidad por dólar (recomendado)             | R1-Distill-Qwen-32B Q4 | [RTX 4090 24 GB](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=deepseek-r1) o A100 de 40 GB |
| Máxima calidad destilada                          | R1-Distill-Llama-70B   | 2× A100 de 80 GB                                                                                                              |
| Investigación, razonamiento de fidelidad completa | DeepSeek-R1 671B       | clúster de 8× H100                                                                                                            |

### Repositorios de HuggingFace

| Variante            | Repositorio                                                                                                   |
| ------------------- | ------------------------------------------------------------------------------------------------------------- |
| R1 completo         | [deepseek-ai/DeepSeek-R1](https://huggingface.co/deepseek-ai/DeepSeek-R1)                                     |
| Destilado Llama-70B | [deepseek-ai/DeepSeek-R1-Distill-Llama-70B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-70B) |
| Destilado Qwen-32B  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-32B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B)   |
| Destilado Qwen-14B  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-14B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-14B)   |
| Destilado Llama-8B  | [deepseek-ai/DeepSeek-R1-Distill-Llama-8B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-8B)   |
| Destilado Qwen-7B   | [deepseek-ai/DeepSeek-R1-Distill-Qwen-7B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B)     |
| Destilado Qwen-1.5B | [deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B) |

## Requisitos

{% hint style="warning" %}
**Los equipos multinodo de clase 80GB no aparecen listados en el marketplace de Clore.ai.** Los equipos más grandes listados hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como [bare metal](https://clore.ai/bare-metal) bajo pedido. Consulta [Precios y disponibilidad de GPU](/guides/guides_v2-es/primeros-pasos/pricing.md) antes de dimensionar un despliegue.
{% endhint %}

| Componente      | Mínimo (7B Q4) | Recomendado (32B Q4) |
| --------------- | -------------- | -------------------- |
| VRAM de GPU     | 6 GB           | 24 GB                |
| RAM del sistema | 16 GB          | 32 GB                |
| Disco           | 10 GB          | 30 GB                |
| CUDA            | 12.8+          | 12.8+                |
| Docker          | 24.0+          | 25.0+                |

## Inicio rápido de Ollama

Ollama maneja automáticamente la cuantización, la descarga y la publicación — la ruta más rápida para tener un DeepSeek-R1 en ejecución.

### Instalar y ejecutar

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

# Descarga y ejecuta (elige tu variante):
ollama run deepseek-r1:1.5b    # Borde / pruebas
ollama run deepseek-r1:7b      # Económico — cabe en cualquier GPU de 8 GB+
ollama run deepseek-r1:14b     # Punto ideal de la RTX 4090
ollama run deepseek-r1:32b     # A100 / 2× RTX 4090
ollama run deepseek-r1:70b     # 2× A100 de 80 GB
```

### Ejemplo de sesión interactiva

```
>>> Demuestra que √2 es irracional.

<think>
Usaré una demostración por contradicción.
Supón que √2 es racional, así que √2 = p/q, donde p y q son enteros con mcd(p,q) = 1.
Entonces 2 = p²/q², lo que da p² = 2q².
Esto significa que p² es par, así que p debe ser par. Escribe p = 2k.
Sustituyendo: (2k)² = 2q² → 4k² = 2q² → q² = 2k².
Así que q² también es par, lo que significa que q es par.
Pero si tanto p como q son pares, mcd(p,q) ≥ 2, lo que contradice nuestra suposición.
</think>

**Demostración de que √2 es irracional (por contradicción):**

Supón que √2 = p/q en términos irreducibles (mcd(p,q) = 1). Al elevar al cuadrado se obtiene p² = 2q².
Como p² es par, p es par — escribe p = 2k. Entonces 4k² = 2q², así que q² = 2k²,
lo que significa que q también es par. Esto contradice mcd(p,q) = 1. ∎
```

### Usa la API compatible con OpenAI

```bash
# Inicia Ollama como servidor (si aún no se está ejecutando)
ollama serve &

# Consultar mediante curl
curl -s http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \\
  -d '{
    "model": "deepseek-r1:32b",
    "messages": [{"role": "user", "content": "Factoriza x^4 - 1 completamente sobre los enteros."}],
    "temperature": 0.6
  }' | python3 -m json.tool
```

### Cliente de Python (mediante OpenAI SDK)

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

response = client.chat.completions.create(
    model="deepseek-r1:32b",
    messages=[
        {"role": "user", "content": "Escribe una función de Python para encontrar la subcadena palíndroma más larga."}
    ],
    temperature=0.6,
    max_tokens=4096,
)
print(response.choices[0].message.content)
```

## Configuración de producción de vLLM

vLLM ofrece el mayor rendimiento para servir a varios usuarios con lotes continuos, PagedAttention y caché de prefijos.

### Una sola GPU — 7B / 14B

```bash
pip install vllm

# 7B en cualquier GPU de 16 GB o más
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
    --host 0.0.0.0 --port 8000 \
    --max-model-len 16384

# 14B en RTX 4090 (24 GB)
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-14B \
    --host 0.0.0.0 --port 8000 \
    --max-model-len 16384 \
    --gpu-memory-utilization 0.92
```

### Multi-GPU — 32B (recomendado)

```bash
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --host 0.0.0.0 --port 8000 \
    --tensor-parallel-size 2 \\
    --max-model-len 32768 \
    --gpu-memory-utilization 0.90 \\
    --enable-prefix-caching
```

> **Consejo:** El checkpoint GPTQ o AWQ Q4 de 32B cabe en una sola RTX 4090 (24 GB):
>
> ```bash
> vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
>     --quantization awq --host 0.0.0.0 --port 8000 \
>     --max-model-len 16384
> ```

### Multi-GPU — 70B

```bash
vllm serve deepseek-ai/DeepSeek-R1-Distill-Llama-70B \
    --host 0.0.0.0 --port 8000 \
    --tensor-parallel-size 4 \\
    --max-model-len 32768 \
    --gpu-memory-utilization 0.90
```

### Consulta el endpoint de vLLM

```bash
curl -s http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \\
  -d '{
    "model": "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    "messages": [{"role": "user", "content": "Resuelve: encuentra todos los primos p tales que p^2 + 2 también sea primo."}],
    "temperature": 0.6,
    "max_tokens": 4096
  }'
```

## Transformers / Python (con `<think>` análisis de etiquetas)

Usa HuggingFace Transformers cuando necesites un control preciso sobre la generación o quieras integrar R1 en una canalización de Python.

### Generación básica

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

MODEL = "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B"

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

prompt = "¿Cuál es la suma de los primeros 100 enteros positivos?"
messages = [{"role": "user", "content": prompt}]
input_text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(input_text, return_tensors="pt").to(model.device)

with torch.no_grad():
    output = model.generate(
        **inputs,
        max_new_tokens=2048,
        temperature=0.6,
        do_sample=True,
    )

full_response = tokenizer.decode(output[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=True)
print(full_response)
```

### Análisis `<think>` etiquetas

```python
def parse_r1_response(text: str) -> dict:
    """Divide una respuesta de DeepSeek-R1 en las partes de razonamiento y respuesta."""
    think_match = re.search(r"<think>(.*?)</think>", text, re.DOTALL)
    thinking = think_match.group(1).strip() if think_match else ""
    answer = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL).strip()
    return {
        "thinking": thinking,
        "answer": answer,
        "thinking_tokens": len(thinking.split()),
    }

result = parse_r1_response(full_response)
print(f"El modelo razonó durante {result['thinking_tokens']} palabras")
print(f"Respuesta: {result['answer']}")
```

### Streaming con `<think>` seguimiento de estado

```python
from openai import OpenAI

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

stream = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    messages=[{"role": "user", "content": "Deriva la fórmula cuadrática a partir de ax² + bx + c = 0."}],
    stream=True,
    max_tokens=4096,
    temperature=0.6,
)

in_think = False
for chunk in stream:
    token = chunk.choices[0].delta.content or ""
    if "<think>" in token:
        in_think = True
        print("[Razonamiento] ", end="", flush=True)
        continue
    if "</think>" in token:
        in_think = False
        print("\n[Respuesta] ", end="", flush=True)
        continue
    if not in_think:
        print(token, end="", flush=True)
print()
```

## Despliegue con Docker en Clore.ai

### Docker de Ollama (lo más simple)

**Imagen Docker:** `ollama/ollama` **Puertos:** `22/tcp, 11434/http`

```bash
# En la instancia de Clore
docker run -d --gpus all \
    -v ollama_data:/root/.ollama \
    -p 11434:11434 \
    --name deepseek-r1 \
    ollama/ollama

# Descarga y sirve el modelo
docker exec deepseek-r1 ollama pull deepseek-r1:32b
```

### Docker de vLLM (producción)

**Imagen Docker:** `vllm/vllm-openai:latest` **Puertos:** `22/tcp, 8000/http`

```yaml
# docker-compose.yml
version: "3.8"
services:
  deepseek-r1:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - hf_cache:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN:-}
    command: >
      --model deepseek-ai/DeepSeek-R1-Distill-Qwen-32B
      --host 0.0.0.0 --port 8000
      --tensor-parallel-size 2
      --max-model-len 32768
      --gpu-memory-utilization 0.90
      --enable-prefix-caching
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 300s
volumes:
  hf_cache:
```

Despliega en Clore.ai:

1. Abre [clore.ai/marketplace](https://clore.ai/marketplace)
2. Filtrar por **2× GPU, 48 GB o más de VRAM en total** (p. ej., 2× RTX 4090 o A100 de 80 GB)
3. Configura la imagen de Docker en `vllm/vllm-openai:latest`
4. Mapea el puerto **8000** como HTTP
5. Pega el comando del archivo compose anterior en el comando de inicio
6. Conéctate mediante el endpoint HTTP una vez que pase la comprobación de salud

## Consejos para despliegues en Clore.ai

### Elegir la GPU adecuada

| Económico    | GPU              | Costo diario | Mejor variante                    |
| ------------ | ---------------- | ------------ | --------------------------------- |
| Mínima       | RTX 3090 (24 GB) | $0.30 – 1.00 | R1-Distill-Qwen-7B o 14B Q4       |
| Estándar     | RTX 4090 (24 GB) | $0.50 – 2.00 | R1-Distill-Qwen-14B FP16 o 32B Q4 |
| Producción   | A100 80 GB       | $3 – 8       | R1-Distill-Qwen-32B FP16          |
| Alta calidad | 2× A100 de 80 GB | $6 – 16      | R1-Distill-Llama-70B FP16         |

### Ajuste de rendimiento

* **Temperatura 0.6** es el valor predeterminado recomendado para tareas de razonamiento — los propios artículos de DeepSeek usan este valor
* **Establece `max_tokens` generosamente** — los modelos de razonamiento producen `<think>` bloques largos; 4096+ para problemas no triviales
* **Habilita el almacenamiento en caché de prefijos** (`--enable-prefix-caching` (en vLLM) al usar un prompt del sistema compartido
* **Limita la concurrencia** (`--max-num-seqs 16`para cargas de trabajo de razonamiento — cada solicitud usa más cómputo que un chat estándar
* **Usa cuantización Q4** para ajustar 32B en una sola GPU de 24 GB con una pérdida mínima de calidad (la destilación ya comprime el conocimiento de R1)

### Consideraciones sobre la longitud del contexto

Los modelos de razonamiento consumen más contexto que los modelos de chat estándar debido al `<think>` bloque:

| Complejidad de la tarea                   | Longitud típica del razonamiento | Contexto total necesario |
| ----------------------------------------- | -------------------------------- | ------------------------ |
| Aritmética simple                         | \~100 tokens                     | \~300 tokens             |
| Generación de código                      | \~500–1000 tokens                | \~2000 tokens            |
| Matemáticas de competición (AIME)         | \~2000–4000 tokens               | \~5000 tokens            |
| Análisis de investigación de varios pasos | \~4000–8000 tokens               | \~10000 tokens           |

## Solución de problemas

### Fuera de memoria (OOM)

```bash
# Reduce la longitud de contexto
--max-model-len 8192    # en lugar de 32768

# Limita secuencias concurrentes
--max-num-seqs 8

# Usa cuantización
--quantization awq      # o gptq
```

### El modelo no produce `<think>` bloque

Algunos prompts del sistema suprimen el razonamiento. Evita instrucciones como "sé conciso" o "no expliques tu razonamiento". Usa un prompt del sistema mínimo o ninguno en absoluto:

```python
# Bien — conserva el razonamiento
messages = [{"role": "user", "content": "..."}]

# Mal — puede suprimir el razonamiento
messages = [
    {"role": "system", "content": "Sé extremadamente breve. Sin explicaciones."},
    {"role": "user", "content": "..."}
]
```

### Repetitivo o en bucle `<think>` salida

Reduce la temperatura para disminuir la aleatoriedad en la cadena de razonamiento:

```python
temperature = 0.0   # Determinista — mejor para matemáticas/código
temperature = 0.3   # Variación leve — bueno para análisis
```

### Primer token lento (TTFT alto)

Esto es esperado — el modelo genera `<think>` tokens antes de la respuesta visible. Para aplicaciones sensibles a la latencia en las que no se necesita razonamiento, usa [DeepSeek-V3](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-v3.md) en su lugar.

### La descarga se atasca en la instancia de Clore

Las descargas de HuggingFace pueden ser lentas en algunos proveedores. Precarga el modelo en un volumen persistente:

```bash
# Descarga una vez en un volumen
huggingface-cli download deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --local-dir /data/models/deepseek-r1-32b

# Apunta vLLM a la ruta local
vllm serve /data/models/deepseek-r1-32b --host 0.0.0.0 --port 8000
```

## Lecturas adicionales

* [Documento de DeepSeek-R1](https://arxiv.org/abs/2501.12948) — *Incentivar la capacidad de razonamiento en los LLM mediante aprendizaje por refuerzo*
* [GitHub de DeepSeek-R1](https://github.com/deepseek-ai/DeepSeek-R1) — repositorio oficial con fichas de modelo
* [Guía de DeepSeek-V3](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-v3.md) — modelo de propósito general sin razonamiento del mismo laboratorio
* [Guía de vLLM](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — configuración integral de serving en producción
* [Guía de Ollama](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — despliegue local sencillo para cualquier modelo
* [Guía de Open WebUI](/guides/guides_v2-es/modelos-de-lenguaje/open-webui.md) — interfaz de chat con renderizado nativo de `<think>` etiquetas
* [Guía de Qwen 2.5](/guides/guides_v2-es/modelos-de-lenguaje/qwen25.md) — la arquitectura base utilizada por la mayoría de las destilaciones de R1


---

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