MLC-LLM

Despliegue universal de LLM mediante compilación de ML — ejecuta cualquier modelo de lenguaje grande en cualquier hardware con el máximo rendimiento usando compilación de aprendizaje automático.

🌟 Más de 20,000 estrellas en GitHub | Mantenido por el equipo de MLC AI | Licencia Apache-2.0

---

¿Qué es MLC-LLM?

MLC-LLM (Compilación de Aprendizaje Automático para Modelos de Lenguaje Grandes) es un marco universal que permite el despliegue eficiente de modelos de lenguaje grandes en diversos backends de hardware. Aprovechando TVM (Máquina Virtual Tensorial) como su backend de compilación, MLC-LLM compila los modelos LLM directamente a código nativo de hardware, logrando un rendimiento casi óptimo sin ingeniería específica para el hardware.

Capacidades clave

• Compatibilidad universal con hardware — NVIDIA CUDA, AMD ROCm, Apple Metal, Vulkan, WebGPU

• API REST compatible con OpenAI — reemplazo directo para flujos de trabajo existentes

• Múltiples formatos de modelo — Llama, Mistral, Gemma, Phi, Qwen, Falcon y más

• Cuantización de 4 bits / 8 bits — ejecuta modelos grandes en GPUs de consumo

• Interfaz de chat — interfaz web integrada para pruebas inmediatas

• Herramientas de Python y CLI — opciones de integración flexibles

¿Por qué usar MLC-LLM en Clore.ai?

El marketplace de GPU de Clore.ai te da acceso a GPUs NVIDIA de alto rendimiento a tarifas de alquiler competitivas. El enfoque de compilación de MLC-LLM exprime el máximo rendimiento de cada GPU, lo que lo hace ideal para:

• Inferencia de API de producción a escala

• Investigación y evaluación comparativa entre tamaños de modelo

• Servicio rentable con modelos cuantizados

• Despliegue de varios modelos en una sola instancia de GPU

---

Inicio rápido en Clore.ai

Paso 1: Encuentra un servidor GPU

1. Ve a clore.ai marketplace

2. Filtrar servidores: GPU NVIDIA, mínimo 8 GB de VRAM (se recomiendan 16 GB+ para modelos 7B+)

3. Para un rendimiento óptimo: RTX 3090, RTX 4090, A100 o H100

Paso 2: Desplegar MLC-LLM

Nota: MLC-LLM no publica una imagen Docker oficial preconstruida en Docker Hub. El enfoque de despliegue recomendado es usar una imagen base de NVIDIA CUDA e instalar MLC-LLM mediante pip. Usa nvidia/cuda:12.8.1-devel-ubuntu22.04 como tu imagen base en Clore.ai.

Usa una imagen base de NVIDIA CUDA en la configuración de tu pedido de Clore.ai:

Imagen Docker: nvidia/cuda:12.8.1-devel-ubuntu22.04

Mapeo de puertos:

Puerto del contenedor	Propósito
22	Acceso SSH
8000	Servidor API REST

Variables de entorno recomendadas:

MLC_MODEL=HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC
MLC_HOST=0.0.0.0
MLC_PORT=8000

Script de inicio (ejecutar después de SSH):

pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu121 mlc-ai-nightly-cu121

Paso 3: Conectarse por SSH

ssh root@<clore-node-ip> -p <assigned-ssh-port>

---

Instalación y configuración

Opción A: Usar modelos precompilados (la más rápida)

MLC-AI mantiene una biblioteca de modelos precompilados en Hugging Face. No se necesita compilación:

# Descargar y ejecutar un Llama 3 8B precompilado (cuantizado a 4 bits)
python -m mlc_llm serve HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC \
  --host 0.0.0.0 \\
  --port 8000

Opción B: Compilar tu propio modelo

Para modelos personalizados o requisitos específicos de cuantización:

# Paso 1: Convertir los pesos del modelo
python -m mlc_llm convert_weight \
  ./ruta/a/modelo \
  --quantization q4f16_1 \
  --output ./compiled/model-q4f16_1

# Paso 2: Generar la configuración del modelo
python -m mlc_llm gen_config \
  ./ruta/a/modelo \
  --quantization q4f16_1 \
  --conv-template llama-3 \
  --output ./compiled/model-q4f16_1

# Paso 3: Compilar el modelo
python -m mlc_llm compile \
  ./compiled/model-q4f16_1/mlc-chat-config.json \
  --device cuda \
  --output ./compiled/model-q4f16_1/lib.so

Tiempo de compilación: Compilar un modelo 7B suele tardar de 10 a 30 minutos en la primera ejecución. Los artefactos compilados se almacenan en caché y se reutilizan en lanzamientos posteriores.

---

Ejecutar el servidor API

Iniciar el servidor compatible con OpenAI

python -m mlc_llm serve \
  HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC \
  --host 0.0.0.0 \\
  --port 8000 \\
  --max-batch-size 4 \
  --max-total-sequence-length 8192

Salida de inicio del servidor

[2024-01-01 12:00:00] INFO: Cargando modelo desde HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC
[2024-01-01 12:00:15] INFO: Modelo cargado correctamente
[2024-01-01 12:00:15] INFO: Iniciando servidor en 0.0.0.0:8000
[2024-01-01 12:00:15] INFO: API compatible con OpenAI disponible en http://0.0.0.0:8000/v1

Endpoints de API disponibles

Endpoint	Método	Descripción
/v1/chat/completions	POST	Completions de chat (formato OpenAI)
/v1/completions	POST	Completions de texto
/v1/models	GET	Listar modelos disponibles
/v1/debug/dump_event_trace	GET	Depuración de rendimiento

---

Ejemplos de uso de la API

Completions de chat (Python)

from openai import OpenAI

# Apunta a tu servidor de Clore.ai
client = OpenAI(
    base_url="http://<clore-node-ip>:<api-port>/v1",
    api_key="none"  # MLC-LLM no requiere autenticación por defecto
)

response = client.chat.completions.create(
    model="Llama-3-8B-Instruct-q4f16_1-MLC",
    messages=[
        {"role": "system", "content": "Eres un asistente útil."},
        {"role": "user", "content": "Explica la computación cuántica en términos sencillos."}
    ],
    temperature=0.7,
    max_tokens=512
)

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

Respuesta en streaming

stream = client.chat.completions.create(
    model="Llama-3-8B-Instruct-q4f16_1-MLC",
    messages=[{"role": "user", "content": "Escribe una historia corta sobre IA."}],
    stream=True,
    max_tokens=1024
)

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

Ejemplo de cURL

curl http://<clore-node-ip>:<api-port>/v1/chat/completions \
  -H "Content-Type: application/json" \\
  -d '{
    "model": "Llama-3-8B-Instruct-q4f16_1-MLC",
    "messages": [
      {"role": "user", "content": "¿Cuánto es 2+2?"}
    ],
    "temperature": 0.7,
    "max_tokens": 100
  }'

---

Modelos precompilados disponibles

MLC-AI proporciona modelos compilados listos para usar en Hugging Face:

Serie Llama 3

# 8B Instruct (recomendado para la mayoría de los casos de uso)
HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC

# 70B Instruct (requiere 40 GB+ de VRAM o varias GPUs)
HF://mlc-ai/Llama-3-70B-Instruct-q4f16_1-MLC

Mistral / Mixtral

HF://mlc-ai/Mistral-7B-Instruct-v0.3-q4f16_1-MLC
HF://mlc-ai/Mixtral-8x7B-Instruct-v0.1-q4f16_1-MLC

Gemma

HF://mlc-ai/gemma-2b-it-q4f16_1-MLC
HF://mlc-ai/gemma-7b-it-q4f16_1-MLC

Phi

HF://mlc-ai/phi-2-q4f16_1-MLC
HF://mlc-ai/Phi-3-mini-4k-instruct-q4f16_1-MLC

Lista completa de modelos: Explora todos los modelos precompilados en huggingface.co/mlc-ai

---

Opciones de cuantización

MLC-LLM admite varios esquemas de cuantización. Elige según tu presupuesto de VRAM:

Cuantización	Bits	Calidad	VRAM (7B)	VRAM (13B)
q4f16_1	4 bits	★★★★☆	~4 GB	~7 GB
q4f32_1	4 bits (acumulación f32)	★★★★☆	~4 GB	~7 GB
q8f16_1	8 bits	★★★★★	~8 GB	~14 GB
q0f16	16 bits (sin cuantización)	★★★★★	~14 GB	~26 GB
q0f32	32 bits (sin cuantización)	★★★★★	~28 GB	~52 GB

Recomendación de VRAM: Deja siempre 2–3 GB de margen para la sobrecarga de CUDA y la caché KV. Un modelo 7B con q4f16_1 necesita ~6–7 GB en total en una carga de trabajo típica.

---

Despliegue multi-GPU

Para modelos grandes (70B+) que requieren varias GPUs:

# Habilitar paralelismo tensorial en 2 GPUs
python -m mlc_llm serve \
  HF://mlc-ai/Llama-3-70B-Instruct-q4f16_1-MLC \
  --host 0.0.0.0 \\
  --port 8000 \\
  --tensor-parallel-shards 2

Comprueba la topología de la GPU antes de desplegar:

nvidia-smi topo -m  # Comprueba la conectividad NVLink/PCIe

Mejor rendimiento: El multi-GPU funciona mejor con tarjetas conectadas por NVLink (por ejemplo, pares de A100 80GB SXM). Las GPUs conectadas por PCIe mostrarán cuellos de botella en modelos grandes.

---

Interfaz de chat web

MLC-LLM incluye una interfaz web integrada accesible una vez que el servidor está en ejecución:

# Inicia el servidor con la interfaz web habilitada
python -m mlc_llm serve \
  HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC \
  --host 0.0.0.0 \\
  --port 8000 \\
  --enable-debug  # Opcional: habilita el endpoint de depuración

Accede a la interfaz en: http://<clore-node-ip>:<api-port>

---

Ajuste del rendimiento

Optimizar el tamaño de lote

# Aumenta el tamaño de lote para mayor rendimiento (requiere más VRAM)
python -m mlc_llm serve \
  HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC \
  --host 0.0.0.0 \\
  --port 8000 \\
  --max-batch-size 8 \
  --max-total-sequence-length 16384 \
  --prefill-chunk-size 2048

Monitorizar el uso de la GPU

# En una terminal separada
watch -n 1 nvidia-smi

# Monitorización más detallada
nvidia-smi dmon -s u  # Métricas de uso en streaming

Medir el rendimiento

import time
from openai import OpenAI

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

start = time.time()
response = client.chat.completions.create(
    model="Llama-3-8B-Instruct-q4f16_1-MLC",
    messages=[{"role": "user", "content": "Cuenta del 1 al 100"}],
    max_tokens=512
)
elapsed = time.time() - start

tokens = response.usage.completion_tokens
print(f"Rendimiento: {tokens/elapsed:.1f} tokens/seg")

---

Configuración con Docker Compose

Para un despliegue listo para producción en Clore.ai usando una imagen base NVIDIA CUDA con MLC-LLM instalado mediante pip:

version: '3.8'
services:
  mlc-llm:
    image: nvidia/cuda:12.8.1-devel-ubuntu22.04
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
    ports:
      - "8000:8000"
    volumes:
      - ./models:/root/models
      - mlc-cache:/root/.cache/mlc_llm
    command: >
      bash -c "pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu121 mlc-ai-nightly-cu121 &&
      python -m mlc_llm serve
      HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC
      --host 0.0.0.0
      --port 8000
      --max-batch-size 4"
    restart: unless-stopped

volumes:
  mlc-cache:

---

Solución de problemas

Fallo en la descarga del modelo

# Comprueba la conectividad a Internet
curl -I https://huggingface.co

# Descargar manualmente con huggingface-cli
pip install huggingface_hub
huggingface-cli download mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC

Falta de memoria (OOM)

# Reduce la longitud de contexto
python -m mlc_llm serve MODEL \
  --max-total-sequence-length 4096  # Reducir desde el valor predeterminado

# Usa una cuantización más agresiva
# Cambia de q8f16_1 a q4f16_1

Incompatibilidad de versión de CUDA

# Comprueba la versión de CUDA
nvcc --version
nvidia-smi | grep CUDA

# Para servidores CUDA 12.8, instala:
pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu121 mlc-ai-nightly-cu121

# Para servidores CUDA 13.x, instala:
pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu122 mlc-ai-nightly-cu122

Error común: Las ruedas pip de MLC-LLM son específicas de la versión de CUDA. Asegúrate de instalar la variante correcta que coincida con la versión de CUDA de tu servidor. Consulta las ruedas disponibles en mlc.ai/wheels.

Servidor no accesible

# Verifica que el puerto esté escuchando
ss -tlnp | grep 8000

# Comprueba el firewall
iptables -L -n | grep 8000

# Prueba localmente primero
curl http://localhost:8000/v1/models

---

Recomendaciones de GPU para Clore.ai

El enfoque de compilación de MLC-LLM ofrece un rendimiento casi óptimo en cada nivel de GPU. Elige según el tamaño del modelo y el presupuesto:

GPU	VRAM	Precio de Clore.ai	Ideal para	Rendimiento (Llama 3 8B Q4)
RTX 3090	24 GB	$0.07–0.21/h	Modelos 7B–13B, servicio económico	~85 tok/s
RTX 4090	24 GB	$0.14–0.42/h	Modelos 7B–34B, servicio rápido	~140 tok/s
A100 40GB	40 GB	bare metal	34B–70B, API de producción	~110 tok/s
A100 80GB	80 GB	bare metal	70B+, servicio multi-modelo	~130 tok/s
H100 SXM	80 GB	~$1.04/h	Máximo rendimiento, FP8	~280 tok/s

Punto de partida recomendado: La RTX 3090 a $0.07–0.21/h es la mejor relación precio-rendimiento para servir Llama 3 8B y Mistral 7B mediante MLC-LLM. Los kernels compilados extraen una utilización casi máxima de las GPUs de consumo.

Para modelos 70B (por ejemplo, Llama 3 70B Q4): usa A100 40GB (bare metal) o dos RTX 3090 mediante paralelismo tensorial.

---

Recursos

• 📦 Ruedas Pip: mlc.ai/wheels (instalar mediante pip, no hay imagen de Docker Hub disponible)

• 🐙 GitHub: github.com/mlc-ai/mlc-llm

• 📚 Documentación: llm.mlc.ai/docs

• 🤗 Modelos precompilados: huggingface.co/mlc-ai

• 💬 Discord: discord.gg/9Xpy2HGBuD