VLLM on Intellectual Guides

Fábula diaria de conceptos de posgrado: Decodificación Especulativa (Speculative Decoding)

Mon, 17 Aug 2026 00:00:00 +0000

¡Buenas noches! Aquí tienes la “Fábula diaria de conceptos de posgrado” de hoy.

El astuto aprendiz del escritorio real

En el corazón de la capital del imperio, el Escritorio Real se enfrentaba a una crisis sin precedentes.

El Gran Erudito del imperio, “Baltasar”, era la única persona viva con la sabiduría suficiente para redactar el código legal sagrado. Poseía una memoria fotográfica y en su mente guardaba diez millones de textos antiguos. Sin embargo, tenía un defecto fatal: escribía demasiado despacio.

El rigor del erudito rozaba la obsesión. Por cada palabra que escribía, hojeaba incontables tomos pesados en la biblioteca de su mente, deliberaba con cuidado y solo entonces posaba lentamente la palabra en el papel. Tras escribir esa palabra, reconsideraba todo lo que acababa de escribir para deducir la siguiente. Por eso, solo podía producir una palabra por minuto. El frente necesitaba con urgencia nuevos decretos, pero el erudito solo podía soltarlos palabra a palabra.

En ese momento, el escritorio contaba con un joven aprendiz llamado “Leo”. El saber de Leo no se acercaba ni de lejos al del erudito —los libros que llevaba en la cabeza no llegaban ni al uno por ciento de los del erudito—, pero tenía una virtud: era rapidísimo y muy hábil para adivinar los pensamientos del erudito.

Tras observar durante unos días, Leo le hizo una propuesta audaz al erudito.

“Maestro, en lugar de agonizar con cada palabra desde cero, ¿por qué no cambiamos la forma de trabajar?”, dijo Leo. “Deje que sea su ‘redactor de borradores’. De un tirón, adivinaré las cinco palabras que probablemente escribirá a continuación y las anotaré rápidamente en una pizarra. Después, usted solo tiene que mirar la pizarra.”

El erudito frunció el ceño. “¡Absurdo! Tu saber es superficial; si las palabras que escribes son erróneas, ¡arruinarán la dignidad del código!”

“Maestro, me malinterpreta”, explicó Leo con una sonrisa. “Concebir una palabra de la nada le cuesta un enorme esfuerzo de acarrear tomos por su mente; pero echar un vistazo a unas palabras y juzgar si concuerdan con su intención le resulta sencillísimo y rapidísimo. Si las palabras que he escrito le parecen correctas, basta con que las selle. En cuanto detecte una sola palabra que difiera de lo que tenía en mente, borre esa palabra y todo lo que la sigue, escriba usted mismo la palabra correcta, y yo retomaré las conjeturas a partir de la palabra que corrigió.”

Medio dudando, el erudito accedió.

Comenzó el trabajo. Leo escribió velozmente en la pizarra: “el imperio / gravará / con impuestos / al norte”.

El erudito lo recorrió con la vista y su mente completó la verificación al instante: ¡las palabras encajaban a la perfección con su hilo de pensamiento! De inmediato estampó su gran sello. Una frase que antes le habría llevado cinco minutos de agonía quedaba ahora lista en segundos.

Luego Leo escribió rápidamente: “la tasa impositiva / es / al año / cincuenta / monedas / de oro”.

El erudito le echó un vistazo, frunció el ceño y señaló la cuarta palabra: “Mal. No cincuenta, sino ‘cien’.”

De un trazo de su pincel, el erudito borró “cincuenta / monedas / de oro” y escribió “cien” de su puño y letra.

Entonces, mirando la palabra “cien”, Leo volvió a iniciar sus rápidas conjeturas y borradores.

Aunque Leo a veces se equivocaba, acertaba con precisión la mayoría de las construcciones habituales. Y lo más asombroso de todo: la calidad y la redacción finales del código resultaron ser “exactamente idénticas” a las que el erudito habría logrado palabra por palabra —sin concesión alguna—, y sin embargo la velocidad global de redacción se multiplicó varias veces.

La revelación: decodificación especulativa (Speculative Decoding)

Lo que describe esta historia es un algoritmo de nivel de posgrado excepcionalmente elegante y clave del campo de la aceleración de la inferencia en grandes modelos de lenguaje (LLM): la decodificación especulativa (Speculative Decoding). Es también una de las técnicas centrales que usan los motores de inferencia de alto rendimiento modernos (como vLLM) para superar los cuellos de botella del hardware.

En la generación de texto tradicional de un LLM, el modelo debe generar de forma autorregresiva: un token tras otro. En modelos grandes con decenas de miles de millones de parámetros (por ejemplo, la clase Qwen 35B), generar cada token requiere acarrear decenas de gigabytes de pesos desde la memoria de la GPU hasta los núcleos de cómputo. Esto hace que el cuello de botella de la inferencia en modelos grandes no sea el cómputo (Compute), sino el ancho de banda de memoria (Memory Bandwidth) — igual que, en la historia, el erudito tiene que acarrear laboriosamente tomos pesados para escribir una sola palabra.

La decodificación especulativa rompe con ingenio este punto muerto:

Introduce un modelo borrador (Draft Model) diminuto y rapidísimo (el aprendiz Leo) para generar velozmente varios tokens consecutivos de una sola vez.
Luego entrega esos tokens generados al modelo objetivo (Target Model), grande y preciso (el erudito), para una única ronda de verificación en paralelo (Parallel Verification).
Como el modelo objetivo, al verificar los tokens dados, puede aprovechar plenamente el enorme cómputo paralelo de la GPU (compute-bound), juzga en un instante si la distribución de probabilidad de esos tokens coincide con su propia salida.
Si se aceptan, equivale a haber generado varios tokens en una sola pasada hacia adelante (forward pass); si un token se rechaza, el modelo lo corrige en ese punto, descarta las conjeturas posteriores y vuelve a empezar.

La propiedad matemática más fascinante es esta: mediante un algoritmo específico de muestreo por rechazo en la verificación, la decodificación especulativa puede garantizar que la distribución de probabilidad de la salida final sea matemáticamente “100% equivalente” a la que el modelo objetivo habría producido por sí solo, en su lenta generación, sin pérdida alguna de calidad.

Correspondencia de la metáfora

Elemento de la historia	Concepto de inferencia en LLM	Explicación
El Gran Erudito “Baltasar”	Modelo objetivo (Target Model)	El gran modelo de lenguaje de enorme número de parámetros y alta precisión.
El astuto aprendiz “Leo”	Modelo borrador (Draft Model / Proposer)	Un modelo de lenguaje pequeño, diminuto en parámetros y rapidísimo en cómputo (o arquitecturas recientes de predicción multicabezal como MTP / Medusa).
Acarrear tomos pesados para escribir	Limitado por el ancho de banda de memoria (Memory-bandwidth bound)	La latencia que causa acarrear los pesos del modelo en la generación autorregresiva tradicional.
Recorrer con la vista la frase de la pizarra	Verificación en paralelo (Parallel Verification)	El modelo objetivo aprovecha la ventaja de cómputo de la GPU para evaluar las probabilidades de varios tokens en una sola pasada.
Estampar el sello / borrar y reescribir	Criterio de aceptación/rechazo (Acceptance/Rejection Criterion)	Si la predicción del modelo borrador cae dentro de la tolerancia de probabilidad del modelo objetivo, se acepta; si no, se retrocede (Rollback) desde el punto erróneo y el modelo objetivo aporta el token correcto.
La calidad no cambia en absoluto	Generación sin pérdidas (Lossless Generation)	La garantía matemática más importante de la decodificación especulativa: no altera la distribución de probabilidad de salida original del modelo objetivo.

Guía de construcción de infraestructura de IA local: Implementación completa de 0 a vLLM + ComfyUI

Mon, 27 Jul 2026 00:00:00 +0000

¿Por qué construir una infraestructura de IA local?

En 2026, las herramientas de IA se han convertido en la infraestructura fundamental para creadores digitales, desarrolladores y empresas. Sin embargo, la mayoría aún depende de las API en la nube — gastando dinero con cada llamada, arriesgando la privacidad en cada transmisión y quedando atascados por los límites de tasa cada vez.

La infraestructura de IA local te da tres cosas: control total, uso ilimitado y costo marginal cero.

Una vez construida, podrás:

Usar LLM sin límites, sin preocuparte por los costos de la API.
Procesar datos sensibles sin que salgan de tu máquina.
Ejecutar múltiples servicios simultáneamente sin límites de tasa.
Integrar con marcos como Cowork MCP para crear verdaderos equipos de agentes de IA.

Esta guía asume que ya tienes una máquina con GPU (se recomienda DGX GB10, RTX 4090 o mejor). Te guiaré paso a paso para construir un entorno de IA local completo desde cero.

Hoy aprenderás:

Instalar y configurar un servicio de LLM local (vLLM)
Implementar el pipeline de generación de imágenes de ComfyUI
Gestionar la memoria de la GPU y el orden de inicio de los servicios
Automatizar la gestión de servicios (systemd)
Integrar con Cowork MCP para crear un sistema multiagente

Empecemos.

Requisitos previos

Antes de comenzar, asegúrate de tener preparado lo siguiente:

Elemento	Requisito de versión	Comando de verificación
Linux	Ubuntu 22.04+ o Arch	`uname -a`
GPU	NVIDIA RTX 3090+/4090/GB10	`nvidia-smi`
CUDA	≥ 12.4	`nvcc --version`
Docker	≥ 24.0	`docker --version`
Node.js	≥ 20	`node --version`
Python	≥ 3.10	`python3 --version`

Si la memoria de tu GPU es inferior a 24 GB, te recomendamos cerrar las interfaces gráficas o servicios innecesarios antes de comenzar.

Paso 1: Instalar Docker y NVIDIA Container Toolkit

Docker es la forma recomendada de implementar servicios de IA locales, ya que aísla dependencias, conflictos de versiones y la contaminación del sistema.

# Instalar Docker
sudo apt update
sudo apt install -y docker.io docker-compose-v2

# Instalar NVIDIA Container Toolkit (para que Docker pueda usar la GPU)
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt update
sudo apt install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

Verifica la disponibilidad de la GPU:

docker run --rm --gpus all nvidia/cuda:12.4.0-base-ubuntu22.04 nvidia-smi

Si ves la información de la GPU y el uso de memoria, significa que el entorno está configurado correctamente.

Paso 2: Implementar el modelo de lenguaje local vLLM

vLLM es actualmente el marco de inferencia LLM local más eficiente y admite múltiples formatos de modelos (GGUF, GPTQ, AWQ).

2.1 Implementación con Docker

docker run -d \
 --name vllm-server \
 --gpus all \
 -p 8000:8000 \
 -v ~/.cache/huggingface:/root/.cache/huggingface \
 vllm/vllm-openai:latest \
 --model "nvidia/Llama-3.1-Nemotron-70B-Instruct" \
 --gpu-memory-utilization 0.9 \
 --max-model-len 8192

Descripción de parámetros:

--model: El modelo a implementar (se puede reemplazar con cualquier modelo de HuggingFace)
--gpu-memory-utilization: Proporción de la memoria de la GPU a utilizar (0.9 significa el 90%)
--max-model-len: Longitud máxima del contexto

Nota: Si la memoria de tu GPU es inferior a 80 GB, se recomienda comenzar con modelos más pequeños (7B o 13B) antes de probar modelos más grandes.

2.2 Probar el EndPoint de la API

curl -X POST http://localhost:8000/v1/completions \
 -H "Content-Type: application/json" \
 -d '{
 "model": "nvidia/Llama-3.1-Nemotron-70B-Instruct",
 "prompt": "Explica qué es un sistema de IA multiagente",
 "max_tokens": 200
 }'

Si recibes una respuesta, vLLM se ha implementado con éxito.

2.3 Configurar como servicio del sistema (inicio automático)

Crea el archivo de servicio de systemd:

sudo tee /etc/systemd/system/vllm.service << 'EOF'
[Unit]
Description=vLLM Local LLM Server
After=docker.service
Requires=docker.service

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/usr/bin/docker start vllm-server
ExecStop=/usr/bin/docker stop vllm-server

[Install]
WantedBy=multi-user.target
EOF

Habilita e inicia el servicio:

sudo systemctl daemon-reload
sudo systemctl enable vllm.service
sudo systemctl start vllm.service

Paso 3: Implementar la generación de imágenes con ComfyUI

ComfyUI es actualmente la herramienta de generación de imágenes local más potente, compatible con Flux, Stable Diffusion, LTX y varios otros modelos.

3.1 Implementación con Docker

docker run -d \
 --name comfyui \
 --gpus all \
 -p 8188:8188 \
 -v ~/.cache/huggingface:/root/.cache/huggingface \
 -v ~/comfyui-output:/output \
 ghcr.io/ai-forest/comfyui:latest

Esto iniciará ComfyUI en http://localhost:8188.

3.2 Instalación manual (Opción avanzada)

Si necesitas más control, puedes optar por la instalación manual:

# Clonar el repositorio de ComfyUI
cd ~/comfyui
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

# Instalar dependencias
pip install -r requirements.txt

# Instalar nodos personalizados (opcional)
git clone https://github.com/Fannovel16/ComfyUI-Frame-Interpolation.git custom_nodes/
git clone https://github.com/laksjdjoy/deforum-comfy.git custom_nodes/

# Iniciar servicio
python main.py --listen 0.0.0.0 --port 8188

3.3 Descarga de modelos comunes

# Usar HuggingFace CLI para descargar modelos
pip install huggingface_hub
huggingface-cli download stabilityai/stable-diffusion-xl-base-1.0 --local-dir ~/models/sdxl
huggingface-cli download stabilityai/stable-diffusion-3.5-large --local-dir ~/models/sd3.5

Paso 4: Estrategia de gestión de memoria de GPU

Al implementar servicios de IA localmente, la memoria de la GPU es el mayor cuello de botella. Aquí hay algunas experiencias prácticas:

4.1 Comprobar la memoria disponible

free -h
nvidia-smi --query-gpu=memory.used,memory.free --format=csv

4.2 Sugerencia de orden de inicio de servicios

Iniciar vLLM primero (los modelos de lenguaje suelen tener requisitos de memoria fijos)
Iniciar ComfyUI después (la generación de imágenes puede ajustar dinámicamente el uso de la memoria)
Cerrar aplicaciones gráficas innecesarias (navegadores, Discord, etc.)

4.3 Script de monitoreo de memoria

Crea un script de monitoreo simple:

#!/bin/bash
# monitor-gpu.sh
while true; do
 echo "=== $(date) ==="
 nvidia-smi --query-gpu=memory.used,memory.free,temperature.gpu --format=csv
 docker ps --filter "name=vllm\|name=comfyui" --format "table {{.Names}}\t{{.Status}}"
 sleep 30
done

Paso 5: Integración con el marco multiagente Cowork MCP

Una vez que la infraestructura de IA local esté lista, puedes conectarla a Cowork MCP para construir un sistema multiagente.

5.1 Registrar vLLM como el cerebro

# Si usas Hermes Agent
hermes register-cowork

# O configurar manualmente el EndPoint de MCP
# Añade lo siguiente a tu archivo de configuración del Agente:
{
 "mcpServers": {
 "cowork": {
 "url": "http://localhost:6868/mcp",
 "transport": "streamable-http"
 },
 "vllm": {
 "url": "http://localhost:8000/v1",
 "transport": "streamable-http"
 }
 }
}

5.2 Aplicación práctica: Pipeline de producción de contenido de IA local

vLLM local (Generación de contenido) → ComfyUI (Generación de imágenes) → ffmpeg (Postprocesamiento)

Cada paso de este pipeline puede ser coordinado por diferentes agentes de IA:

Agente de Investigación: Usa vLLM para generar el esquema del contenido
Agente de Redacción: Usa vLLM para expandir a un artículo completo
Agente de Imágenes: Usa ComfyUI para generar ilustraciones correspondientes
Agente de Integración: Combina el contenido y las imágenes en la salida final

Paso 6: Automatización y copias de seguridad

6.1 Copia de seguridad de contenedores

# Copia de seguridad del estado del contenedor de ComfyUI
docker commit comfyui comfyui-backup:$(date +%Y%m%d)

# Exportar imagen
docker save comfyui:latest | gzip > ~/backups/comfyui-$(date +%Y%m%d).tar.gz

6.2 Copia de seguridad de modelos

# Copia de seguridad periódica del caché de HuggingFace
rsync -avh ~/.cache/huggingface ~/backups/huggingface-cache/

# O usar rclone para copia de seguridad en la nube
rclone sync ~/.cache/huggingface remote:backup-huggingface --progress

6.3 Script de verificación de estado

Crear un cron job de verificación de estado:

# Verificar el estado del servicio cada 5 minutos
*/5 * * * * curl -f http://localhost:8000/v1/models || echo "vLLM is down at $(date)" | mail -s "vLLM Alert" admin@example.com

Solución de problemas comunes

P1: Docker no puede usar la GPU

# Comprobar si NVIDIA Container Toolkit está instalado
nvidia-ctk runtime verify

# Reiniciar el servicio de Docker
sudo systemctl restart docker

P2: Memoria de GPU insuficiente

# Reducir el uso de memoria de vLLM
# Añadir al comando docker run:
--gpu-memory-utilization 0.7

# O cerrar servicios innecesarios
sudo systemctl stop bluetooth

P3: ComfyUI falla al iniciar

# Comprobar los registros de Docker
docker logs comfyui

# Intentar reiniciar
docker restart comfyui

P4: La descarga de modelos es demasiado lenta

# Usar el sitio espejo de HuggingFace (usuarios de China continental)
export HF_ENDPOINT=https://hf-mirror.com

Próximos pasos

Ahora tienes una infraestructura de IA local completa:

Hoy:

Confirmar que vLLM y ComfyUI funcionan correctamente
Probar los EndPoints de la API, confirmando la generación de contenido e imágenes

Esta semana:

Configurar servicios systemd para asegurar el inicio automático al arrancar
Establecer mecanismos de copia de seguridad y monitoreo
Conectar al menos un backend LLM a Cowork MCP

Este mes:

Explorar el marco Cowork MCP para construir más equipos de agentes de IA
Probar diferentes modelos para encontrar la configuración que mejor se adapte a tus necesidades
Construir tu propio pipeline de producción de contenido de IA

Preguntas frecuentes

P: ¿Qué nivel de GPU necesito para ejecutar estos servicios? R: Se recomienda al menos 24 GB de memoria (RTX 3090/4090). Si la memoria es menor, puedes ejecutar modelos más pequeños (7B-13B) o usar los límites de memoria de Docker.

P: ¿Se puede ejecutar en una máquina sin GPU? R: Sí, pero será muy lento. La inferencia de CPU es factible, pero no práctica para modelos grandes (70B+).

P: ¿Cómo actualizar los modelos? R: Usa HuggingFace CLI: huggingface-cli download <model-name> --local-dir <path>. El contenedor de Docker utilizará automáticamente los modelos locales actualizados.

P: ¿Cuál es la diferencia entre vLLM y Ollama? R: vLLM es un marco optimizado para inferencia de alto rendimiento, que admite más formatos de modelo y funciones avanzadas. Ollama es más ligero y fácil de usar, pero tiene menos funciones. Para una infraestructura de IA local, se recomienda vLLM.

P: ¿Cuál es la diferencia entre ComfyUI y Automatic1111? R: ComfyUI utiliza un flujo de trabajo basado en nodos, que es más flexible y eficiente. Automatic1111 tiene una interfaz gráfica, más amigable para principiantes. Ambos funcionan bien, pero ComfyUI es más popular en entornos de producción.

Tiempo de lectura: unos 15 minutos | Fecha de publicación: 2026-07-27

¿Te resultó útil esta guía? Explora más guías en Slashman Tools. Si deseas implementar rápidamente una infraestructura de IA, revisa nuestra biblioteca de plantillas de cadena de herramientas de IA para obtener archivos de configuración listos para usar.

[- Volver al inicio]