Homelab con GPU 24GB+: Guía Completa de Modelos IA, Herramientas y Stack Profesional (2025)

Meta descripción: Guía definitiva homelab GPU 24GB+ (RTX 3090/4090/5090). LLMs, generación imágenes/video/audio, benchmarks reales, Docker stack completo. Qué puedes ejecutar HOY.

Por Qué 24GB es el Sweet Spot para IA en Homelab

Si tienes una RTX 3090, 4090 o 5090 en tu homelab, estás en el rango óptimo para ejecutar cargas de trabajo de IA profesionales sin depender de la nube. Los 24GB de VRAM (32GB en la 5090) te permiten ejecutar desde LLMs de 70B parámetros hasta generación de imágenes 4K y fine-tuning de modelos custom.

La pregunta no es si puedes ejecutar IA en tu homelab, sino qué específicamente puedes ejecutar y cómo configurarlo para máximo rendimiento.

Esta guía cubre:

• LLMs por categoría de tamaño: 7B-13B, 30B-34B, 70B+ con benchmarks reales
• Motores de inferencia: Ollama, vLLM, llama.cpp, ExLlamaV2
• Generación de imágenes/video/audio: FLUX, SDXL, ComfyUI, Whisper, Bark
• Stack completo Docker con configuración GPU
• Comparativas RTX 3090 vs 4090 vs 5090 con datos reales

LLMs Que Puedes Ejecutar: Por Categoría de Tamaño

7B-13B: Rendimiento Brutal en FP16

Llama 3.1 8B es el caballo de batalla perfecto para 24GB. En FP16 ocupa solo 12.3GB de VRAM, dejando espacio de sobra para contextos largos.

Benchmarks reales:

• RTX 5090: 226 tokens/segundo
• RTX 4090: 213 tokens/segundo
• RTX 3090: 101 tokens/segundo

Mistral 7B ofrece latencia increíble: 130ms hasta el primer token y 170 tokens/segundo sostenidos. Con solo 12.3GB en FP16, funciona perfectamente en las tres GPUs y sorprendentemente supera en benchmarks a Llama 2 13B.

Qwen2.5 8B rompe récords en la RTX 5090: más de 10,400 tokens/segundo en prefill. La versión Coder con cuantización Q6K funciona sin problemas en consumer GPUs.

Modelos 13B: El límite de FP16 en 24GB

LLaMA-13B en FP16 necesita exactamente 24GB de VRAM para inferencia – estás al límite absoluto. En bfloat16 consume 14-15GB para cargar pero 26GB en runtime, haciendo la cuantización casi obligatoria.

Con INT4 en RTX 4090: 110 tokens/segundo – rendimiento más que aceptable.

30B-34B: Cuantización Obligatoria pero Viable

Yi-34B y Qwen2.5-32B representan el tier superior que puedes ejecutar en una sola GPU de 24GB con cuantización agresiva.

Benchmarks RTX 5090 con modelos 32B:

• Prefill a 4K context: ~3,000 tokens/segundo
• Generación: 61 tokens/segundo

Benchmarks RTX 4090:

• Q4KM cuantización: 37-40 tokens/segundo

Qwen2.5-Coder 32B funciona con 32K de contexto a aproximadamente 4.5 bits por peso en 24GB. Una versión 4-bit consume prácticamente toda la VRAM disponible: 23.7GB.

RTX 3090 con 32B @ Q4KM: ~25 tokens/segundo – lento pero funcional.

⚠️ Importante: AWQ INT4 para modelos 32B necesita ~35GB solo para cargar el checkpoint con vLLM (tensor-parallel-size 4, max-model-len 4096). Esto excede 24GB y requiere cuantización 2-bit o setup dual-GPU.

70B+: Los Límites de lo Posible

Llama 3.1 70B es el desafío definitivo. El modelo completo necesita 140GB en FP16, pero con cuantización 2-bit agresiva baja a 21.1GB – técnicamente viable en 24GB.

Cuantización GGUF con Ollama:

• 8-bit: ~35GB VRAM (NO cabe en 24GB)
• 4-bit: ~20GB VRAM ✅
• 2-bit (IQ2_XS): ~12GB VRAM ✅ 60 tokens/segundo

Ventaja RTX 5090 (32GB): Con INT4/INT8, los 70B caben sin spillover a RAM, manteniendo velocidad completa. Un solo layer offloaded reduce el performance a 25% de la velocidad.

Qwen2.5-72B sigue patrones similares: 4-bit cabe en 32GB, requiere 2-bit para 24GB.

Contextos largos (32K tokens): La ventaja de la 5090 sobre la 4090 crece a 50% más rápida. La 5090 mantiene 139,247 tokens de contexto activo a 52 tokens/segundo gracias a sus 1.79 TB/s de bandwidth (vs 1.01 TB/s de la 4090).

Motores de Inferencia: Cuál Usar y Cuándo

Ollama: Simplicidad sin Concesiones

Para qué es perfecto: Desarrollo, pruebas rápidas, uso diario personal. Si estás evaluando Ollama vs LM Studio, Ollama gana en facilidad de integración Docker.

Ventajas:

• Instalación trivial: curl https://ollama.ai/install.sh | sh
• Streaming ultra rápido
• GGUF nativo (cuantización flexible)
• Server en http://localhost:11434

Limitaciones:

• Solo GGUF (no AWQ, GPTQ, EXL2)
• Sin LoRA training
• Sin TTS/STT integrado
• Sin extensiones

Docker Compose:

ollama:
  image: ollama/ollama:latest
  ports:
    - "11434:11434"
  volumes:
    - ollama-data:/root/.ollama
  deploy:
    resources:
      reservations:
        devices:
          - driver: nvidia
            capabilities: ["gpu"]

vLLM: Producción y Máximo Throughput

Para qué es perfecto: APIs de producción, múltiples usuarios concurrentes, máximo rendimiento.

Ventajas clave:

• Hasta 24x más throughput que HuggingFace Transformers
• OpenAI API compatible (drop-in replacement)
• PagedAttention: reduce uso de memoria 50-70%
• Continuous batching: múltiples requests simultáneas
• Scaling de 1 GPU a multi-node sin cambios de código
• Autenticación con --api-key o VLLM_API_KEY

Lanzar servidor:

vllm serve meta-llama/Llama-2-7b-hf \
  --tensor-parallel-size 1 \
  --host 0.0.0.0 \
  --port 8000

Importante: vLLM ejecuta un modelo a la vez definido en startup (vs Ollama que puede cargar múltiples).

Caso de uso homelab: Servir Llama-3 70B a múltiples aplicaciones/usuarios con mínima latencia.

llama.cpp: Máxima Flexibilidad

Para qué es perfecto: Portabilidad, cuantización custom, control total.

Instalación:

brew install llama.cpp  # macOS/Linux
# Windows: usa WSL

Lanzar server:

llama-server \
  --hf-repo microsoft/Phi-3-mini-4k-instruct-gguf \
  --hf-file Phi-3-mini-4k-instruct-q4.gguf \
  -c 4096 \
  --host 0.0.0.0 \
  --port 8080

GUI incluida en: http://localhost:8080

Endpoints OpenAI-compatible:

• /v1/chat/completions
• /completion

Formatos de Cuantización GGUF (modelo 7B)

Sufijos S/M/L: Indican intensidad de cuantización – Q3_K_S es más agresivo que Q3_K_L.

Recomendación: Q4_K_M para producción (usa Q6_K en attention.wv y feed_forward.w2, Q4_K en el resto).

Text Generation WebUI (oobabooga)

Para qué es perfecto: Experimentación, roleplay, múltiples backends.

Ventaja única: Soporte de múltiples backends en una sola UI:

• Transformers
• ExLlama v2
• AutoGPTQ
• AutoAWQ
• GPTQ-for-Llama

Features avanzadas:

• Train LoRA adapters con datos custom
• Cargar/descargar LoRAs on the fly
• Extensiones: Coqui TTS, Whisper STT, traducción, Stable Diffusion, vector DBs
• Roleplay nativo: Characters, historias persistentes

Problema conocido: llama.cpp via Oobabooga puede tener stuttering cada pocos segundos (trade-off por features extra).

ExLlamaV2: Velocidad Pura

Benchmark: llama.cpp toma 2.22x más tiempo que ExLlamaV2 para procesar prompts de 3200 tokens.

Con Flash Attention: EXL2 destroza a llama.cpp incluso con full GPU offload.

Generación: EXL2 es el más rápido, seguido de GPTQ via ExLlama v1. GPTQ via ExLlamaV2 logra 13% más rápido que v1.

Hardware del benchmark: RTX 4090, 10700k, DDR4 3200 MT/s dual-channel.

Comparativa de Cuantización: AWQ vs GPTQ vs EXL2

Tiempo de cuantización: GPTQ toma ~35 min con A10 GPU.

Recomendación:

• Máxima velocidad: EXL2
• Balance speed/VRAM: GPTQ
• Máxima calidad (aceptas más VRAM): AWQ

Generación de Imágenes en 24GB

FLUX (schnell vs dev)

VRAM sin optimizar: ~33GB en bf16 (NO cabe en 24GB)

Con CPU offloading: Baja a 24GB exactos ✅

Quantización GGUF: Ahorra VRAM significativa manteniendo calidad.

Batch processing en 24GB: Usuarios reportan 2048×2048 batch_size=2 en… 6GB usando offloading secuencial + VAE tiling (MUY lento). Para performance real: 16-24GB recomendados.

SDXL: Batch Sizes por GPU

VRAM mínima: 8GB
Recomendado profesional: 12GB+
Base + Refiner: 24GB para workflows complejos

RTX 5090 (32GB): 4x imágenes 1024×1024 en paralelo a VRAM completa.

⚠️ Escalado de resolución: 2048×2048 aumenta VRAM cuadráticamente – se come la GPU rápido.

ComfyUI: El Power User Tool

ComfyUI hace FLUX viable en 24GB mediante CPU offloading + VAE tiling + memory management inteligente. Si vienes de comparar ComfyUI vs Stable Diffusion WebUI, ComfyUI es superior para workflows complejos y memory optimization.

Instalación ComfyUI Manager

cd ComfyUI/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git

Custom Nodes Esenciales

SwarmUI + ComfyUI Backend

SwarmUI usa ComfyUI como backend. Para integrar con Open WebUI:

http://<swarmui_address>:7801/ComfyBackendDirect

Generación de Video

Stable Video Diffusion

VRAM inicial reportada: Hasta 40GB (SCARY ❌)
VRAM real con optimizaciones: 8GB mínimo ✅

Gracias a optimizaciones de ComfyUI, SVD funciona en RTX 3060 12GB.

Configuraciones avanzadas:

• Mínimo recomendado: 16GB (RTX 4080/3090)
• SVD-XT (extended): 24GB+ recomendado

AnimateDiff

VRAM por caso de uso:

• Text-to-video: 8GB suficiente
• Video-to-video: 10GB requerido
• Local básico: 12GB para 512×512 @ 16 frames
• Alta resolución: 21GB para 512×768 @ 24 frames

Batch Size: Representa bloques de animación. Default 16, DiffSynth-Studio usa 32.

Optimizar VRAM: Reduce batch size, inference steps, resolución o aumenta VRAM limit en ComfyUI settings.

Audio y Speech

Whisper large-v3

VRAM mínima: 2.87GB (float16/bfloat16)
VRAM típica: ~10GB
WhisperX: Mínimo 10GB para large-v3

Variantes:

• Tiny: ~1GB
• Large-v3 típico: ~4GB
• Large-v3 batch_size=24 + timestamps=’word’: >20GB

Performance RTX 4090 vs 3090: 297 vs 172 tokens/s (1.7x improvement) en BERT Base fine-tuning FP16.

Bark TTS

Versión completa: ~12GB VRAM
Versión pequeña (8GB): SUNO_USE_SMALL_MODELS=True

Con optimizaciones (Better Transformer + CPU offload): De 5GB → 2GB ✅

GPUs <4GB pueden ejecutar Bark optimizado.

MusicGen

Inference modelos medium (~1.5B params): Mínimo 16GB
Fine-tuning: 10-16GB
GPUs pequeñas: Usa facebook/musicgen-small o secuencias cortas

UIs y Herramientas Prácticas

Open WebUI + AUTOMATIC1111 Integration

docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -e AUTOMATIC1111_BASE_URL=http://host.docker.internal:7860/ \
  -e ENABLE_IMAGE_GENERATION=True \
  -v open-webui:/app/backend/data \
  --name open-webui --restart always \
  ghcr.io/open-webui/open-webui:main

Inter-container communication: Usa http://host.docker.internal:7860/ cuando ambos contenedores están en el mismo host.

AUTOMATIC1111

Puerto default: 7860

⚠️ Problema conocido: AUTOMATIC1111 se vuelve MUY lento si SillyTavern corre simultáneamente. Monitor de recursos obligatorio.

SillyTavern

Ventaja única: Interface unificada para:

• LLM APIs múltiples
• AUTOMATIC1111 image generation
• ComfyUI API integration
• TTS voice models

Best use case: Roleplay, gaming, character management, historias persistentes.

RAG y Vector Databases

Modelos de Embeddings

Opciones populares:

• OpenAI: text-embedding-ada-002
• Hugging Face: Sentence-BERT, all-MiniLM-L6-v2
• Google: Universal Sentence Encoder

VRAM: Modelos de embeddings consumen VRAM mínima vs modelos generativos – caben fácilmente en 24GB junto a otras cargas.

Comparativa Vector Databases

Qdrant highlights:

• Rust = memory safety + velocidad
• Latency y throughput superiores a escala millones
• Binary quantization
• Fast SSD supplementation de RAM

Decisión clave: El embedding model determina calidad/relevancia. La DB afecta performance, scalabilidad y ops.

Fine-tuning en 24GB

LoRA con Unsloth

Capacidades 24GB VRAM:

• Modelos 9B en LoRA 16-bit: ✅
• QLoRA 4-bit: Solo 6.5GB VRAM ✅
• Contexto: 20K tokens (3.5x más largo que HF+FA2)

Velocidad: 2x faster, 70% menos VRAM que alternativas.

Precisión: 2.7x faster con 74% menos memoria vs Transformers + SDPA. 0% degradación de accuracy (sin aproximaciones).

Ejemplo extremo: Alpaca training 3 horas vs 85 horas convencional (30x speedup).

Tecnología: Weight upcasting optimizado, Triton kernels custom, Flash Attention, manual gradient computation para LoRA.

Gradient checkpointing mode: Usa 30% menos VRAM, cabe 2x larger batch sizes.

QLoRA para Modelos Grandes

4-bit precision: Reduce VRAM >75%

Integración Unsloth: Combina speed/memory optimizations de Unsloth + QLoRA sin pérdida de accuracy.

Benchmarks Reales: RTX 3090 vs 4090 vs 5090

RTX 3090 (24GB GDDR6X)

Performance:

• 8B models: 101 tokens/s
• Llama2-7B mixed 2/4-bit: 45.2 tokens/s
• 32B @ Q4KM: ~25 tokens/s

Precio eBay: $950 → $9.34 por token (mejor balance precio/performance)

RTX 4090 (24GB GDDR6X, 1.01 TB/s)

Performance:

• 8B models: 213 tokens/s
• Llama-2-7B INT4: 194 tokens/s
• Llama-2-13B INT4: 110 tokens/s
• 32B @ Q4KM: 37-40 tokens/s
• BERT Base FP16 fine-tuning: 297 tokens/s

Tensor Cores FP4: 1,300 TOPS

RTX 5090 (32GB GDDR7, 1.79 TB/s)

Performance:

• 8B models: 226 tokens/s
• 32B generación: 61 tokens/s
• 32B @ 4K context prefill: ~3,000 tokens/s
• Qwen3 8B prefill: >10,400 tokens/s
• Contexto activo máximo: 139,247 tokens @ 52 tokens/s

Tensor Cores FP4: >3,300 TOPS (154% improvement vs 4090)

Mejoras Generacionales

5090 vs 4090:

• Promedio: +35% performance
• Computer Vision: +44%
• NLP: +72%
• Contextos largos (32K): +50%
• Bandwidth: +78% (1.79 vs 1.01 TB/s)

5090 vs 3090:

• Ollama LLM inference: +108% (más del doble)

Consumo y Eficiencia

TDP:

• RTX 3090: 350W
• RTX 4090: 450W (+100W)
• RTX 5090: >450W

Throughput por Watt (4090 vs 3090): 0.92x a 1.5x

A pesar de consumir 100W más, la 4090 ofrece eficiencia similar o ligeramente mejor cuando se normaliza por performance.

Throughput absoluto (4090 vs 3090): 1.3x a 1.9x dependiendo de modelo/precisión.

Docker Stack Completo para Homelab

Configuración GPU Base

deploy:
  resources:
    reservations:
      devices:
        - driver: nvidia
          capabilities: ["gpu"]
          count: all

docker-compose.yml Completo

version: '3.8'

services:
  ollama:
    image: ollama/ollama:latest
    ports:
      - "11434:11434"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - ollama-data:/root/.ollama
    networks:
      - ai-stack
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              capabilities: ["gpu"]
              count: all

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
      - AUTOMATIC1111_BASE_URL=http://stable-diffusion:7860/
      - ENABLE_IMAGE_GENERATION=True
    volumes:
      - open-webui:/app/backend/data
    networks:
      - ai-stack
    depends_on:
      - ollama

  stable-diffusion:
    image: goolashe/automatic1111-sd-webui
    ports:
      - "7860:7860"
    volumes:
      - sd-models:/models
      - sd-outputs:/outputs
    networks:
      - ai-stack
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              capabilities: ["gpu"]
              count: all

  vllm:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    environment:
      - VLLM_API_KEY=your-api-key-here
    command: --model meta-llama/Llama-2-7b-hf --tensor-parallel-size 1
    networks:
      - ai-stack
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              capabilities: ["gpu"]
              count: all

networks:
  ai-stack:
    driver: bridge

volumes:
  ollama-data:
  open-webui:
  sd-models:
  sd-outputs:

Tips de Configuración

✅ Usa Docker volumes (no bind mounts) para Ollama/Open WebUI – mayor confiabilidad
✅ CPU/RAM generosa en Docker Desktop
✅ Verifica GPU en logs: “Nvidia GPU detected via cudart»
✅ Inter-container: host.docker.internal para comunicación mismo host
✅ Monitor recursos cuando corres múltiples servicios AI simultáneos

Estrategia de Asignación de Recursos

Single 24GB Card

Distribución VRAM:

• 12-14GB: LLM inference primaria (Ollama/vLLM)
• 8-10GB: Image generation (AUTOMATIC1111/ComfyUI)
• 2-4GB: System overhead + context caching

⚠️ Evita: Correr ambos a capacidad máxima simultáneamente

Workflow recomendado:

• Primario: Ollama con 7B-13B para tareas LLM diarias
• Secundario: AUTOMATIC1111 start/stop según necesidad
• Terciario: Whisper para transcripción
• Estrategia: Switch entre workloads vs todo simultáneo

Dual 24GB Cards

Card 1:

• LLM inference dedicada (vLLM/Ollama)
• Hasta modelos 32B

Card 2:

• Image/video generation
• Fine-tuning workloads

Ventaja: Operación paralela texto + imagen sin competencia.

Single 32GB Card (RTX 5090)

Capacidades simultáneas:

• ✅ Ollama + AUTOMATIC1111 + Open WebUI stack completo
• ✅ Modelos 70B con 4-bit quantization
• ✅ Contextos largos (128K+) con modelos medium
• ✅ Fine-tune modelos grandes con QLoRA

Headroom:

• 20-24GB: LLM inference (modelos grandes, contextos largos)
• 10-12GB: Image/video generation
• Buffer cómodo para múltiples servicios concurrentes

Casos de Uso Reales

Setup 1: Developer Fullstack (RTX 4090 24GB)

Stack:

• Ollama: Llama-3.1-8B para code generation diaria (perfecto si usas Cursor como editor con IA)
• Open WebUI: Interface unificada
• AUTOMATIC1111: Generación UI mockups/assets
• Whisper large-v3: Transcripción meetings

Performance:

• Code generation: 213 tokens/s
• Mockup generation: 2-3 imágenes 1024×1024 simultáneas
• Transcripción: Real-time con buffer

Setup 2: Content Creator (RTX 5090 32GB)

Stack:

• vLLM: Llama-3.1-70B @ 4-bit para scripts largos
• ComfyUI: FLUX workflows para thumbnails 4K
• Whisper + Bark: Transcripción + voice-over

Performance:

• 70B a velocidad completa sin spillover RAM
• FLUX sin CPU offloading (más rápido)
• Procesamiento simultáneo audio + video

Setup 3: ML Researcher (Dual RTX 3090)

Card 1:

• Text Gen WebUI: Experimentación multi-backend
• LoRA training: Modelos 7B-9B

Card 2:

• SDXL + Refiners: Generación dataset custom
• Vector DB (Qdrant): Embeddings research

Performance:

• Training LoRA: ~3 horas Alpaca con Unsloth
• SDXL batch generation para datasets
• Dual-card isolation = sin competencia recursos

Conclusión: Tu Homelab vs La Nube

Con una GPU de 24GB+ en tu homelab tienes capacidades que hace 2 años solo estaban disponibles en cloud a $$/hora:

✅ LLMs 70B locales (privacidad total)
✅ Generación imágenes profesionales (FLUX, SDXL)
✅ Fine-tuning custom (tus datos, tu modelo)
✅ APIs propias (vLLM OpenAI-compatible)
✅ Latencia <100ms (vs 200-500ms cloud)
✅ Sin rate limits (corre 24/7)
✅ Costo fijo (electricidad vs $/token)

RTX 3090: Mejor precio/performance usado ($950)
RTX 4090: Balance óptimo performance/consumo
RTX 5090: Máxima capacidad, modelos 70B cómodos, contextos largos

La pregunta ya no es si montar un homelab con GPU, sino cuándo empezar 🚀

Preguntas Frecuentes

¿Puedo ejecutar modelos 70B en una RTX 4090 24GB?

Sí, con cuantización 4-bit (~20GB VRAM) u Ollama IQ2_XS 2-bit (~12GB) a ~60 tokens/s. Performance aceptable pero la RTX 5090 32GB ofrece experiencia mucho mejor sin spillover a RAM.

¿Qué es mejor para homelab: Ollama o vLLM?

Ollama para uso personal/desarrollo (fácil, múltiples modelos). vLLM para producción/APIs (24x throughput, OpenAI-compatible, multi-usuario). Puedes correr ambos en el mismo stack.

¿Cuánta electricidad consume un homelab con RTX 4090?

RTX 4090 = 450W bajo carga. 24/7 = ~324 kWh/mes. A $0.15/kWh = ~$49/mes. Vs cloud GPUs ($1-3/hora) = ROI en 3-6 meses uso intensivo.

¿ComfyUI o AUTOMATIC1111 para FLUX?

ComfyUI para FLUX – mejor memory management, workflows avanzados, optimizaciones para 24GB. AUTOMATIC1111 mejor para SDXL tradicional y simplicidad.

¿Necesito NVLink para dual GPU?

No obligatorio pero ayuda. Sin NVLink puedes usar dual GPUs asignando workloads separados por card. Con NVLink puedes tensor-parallel multi-GPU para modelos >24GB.

¿Qué cuantización usar para mejor calidad?

Q8_0 prácticamente indistinguible de FP16. Q4_K_M balance óptimo (3.3x compresión, +0.0535 perplexity). Q5_K_M si tienes VRAM de sobra.

¿Puedo fine-tunear Llama-3.1-70B en 24GB?

Sí con QLoRA 4-bit + Unsloth. Consume ~6.5GB VRAM. Entrenamiento lento vs modelos pequeños pero viable. RTX 5090 32GB mucho más cómodo.

¿Docker necesario o puedo instalar nativo?

No obligatorio pero MUY recomendado. Docker facilita: networking entre servicios, GPU sharing, updates, rollbacks, isolation. Stack completo funciona sin conflictos.

¿VRAM de consumer GPU equivale a pro cards?

RTX 4090 24GB GDDR6X vs A6000 48GB: Mismo chip (AD102), consumer tiene boost clocks más altos, pro tiene ECC + doble VRAM. Para inference/fine-tuning homelab, consumer GPUs son óptimas.

¿Whisper large-v3 funciona real-time?

Sí en RTX 4090/5090. Latencia típica 10GB VRAM, procesa más rápido que audio real-time. Tiny/base models (~1-2GB) funcionan real-time incluso en GPUs pequeñas.

¿Qué modelos multimodales (visión) puedo ejecutar?

Llava-1.5-13B (~14GB), Llama-3.2-Vision (11B/90B variants), Qwen2-VL caben en 24GB con cuantización. RTX 5090 puede 90B @ 4-bit.

¿Vector DB en GPU o CPU?

Qdrant/Chroma/Weaviate funcionan en CPU/RAM. Embeddings se generan en GPU luego se almacenan en DB (CPU/disco). GPU solo necesaria para generar/query embeddings, no para storage.

¿Temperaturas seguras 24/7?

<85°C safe, <80°C ideal. Undervolting RTX 4090/5090 puede reducir 10-15°C sin pérdida performance. Cooling adecuado obligatorio para cargas 24/7.

¿Vale la pena RTX 5090 vs 4090 usado?

RTX 5090: +35% avg performance, +78% bandwidth, 32GB vs 24GB. Para modelos 70B y contextos largos, sí. Para 7B-34B, RTX 4090 usado ($1,200-1,500) mejor value.

Guías Complementarias para tu Homelab IA

• Fine-Tuning de LLMs – Aprende a ajustar modelos con tu GPU
• Ollama vs LM Studio – Las mejores herramientas para ejecutar LLMs locales
• Tailscale para Homelab – Accede a tu homelab de forma segura desde cualquier lugar
• DGX Spark vs Servidor IA Casero – Comparativa con infraestructura profesional