- Busco un modelo que permita conversación básica en una 5060ti + 16GB de VRAM. Si es posible, que sea rápido y funcione casi en tiempo real
Resumen de respuestas
- Varios modelos de 8B~14B y 30B parámetros pueden funcionar de forma eficiente con 16GB de VRAM; entre los más recomendados están Qwen3, DeepSeek-R1, Mistral y Gemma3
- Ejecutar LLMs localmente tiene ventajas en rendimiento, costo y privacidad, pero para encontrar el mejor ajuste real hace falta experimentación y tuning individual
- Se comparten muchos consejos para optimizar el hardware, como el tamaño del archivo del modelo, el nivel de cuantización (Q4~Q6, etc.) y la carga distribuida entre GPU y RAM
- Existen varias herramientas como Ollama, LM Studio, llama.cpp y OpenWebUI, cada una con pros y contras en accesibilidad, flexibilidad y facilidad de gestión de modelos
- Las comunidades en línea (por ejemplo, Reddit LocalLLaMA) son útiles para obtener noticias recientes y consejos prácticos, aunque conviene tener cuidado con exageraciones o desinformación
Recomendaciones principales de LLM y consejos de uso
- Qwen3: hay modelos de distintos tamaños como 8B/14B/30B; los de 8B~14B se pueden usar cómodamente con 16GB de VRAM. Tienen muy buen rendimiento de reasoning, y gracias a la arquitectura MoE (mezcla de expertos) algunos modelos grandes también pueden ejecutarse usando offloading a RAM
- DeepSeek-R1-0528-Qwen3-8B: está bien valorado como uno de los modelos 8B más recientes por su rendimiento de reasoning. En 8B, con cuantización Q4~Q6, encaja en unos 4GB~8GB de VRAM
- Mistral Small 3.1: se recomiendan las versiones de 14B o 24B; ofrece buena calidad de conversación y relativamente menos censorship. Además, tiene capacidad de entrada de imágenes
- Gemma3: modelo de Google con fortalezas en conversaciones intuitivas. Sin embargo, se comenta que tiene una fuerte inclinación tipo HR y muchos disclaimers. También alucina con relativa frecuencia
- Devstral: modelo grande basado en Mistral. Por encima de 30B puede volverse lento en 16GB de VRAM
- Dolphin, Abliterated: versiones con menos censorship, útiles en situaciones fuera de lo rutinario
Optimización de hardware y entorno de ejecución
- Configuración de cuantización: con Q4, Q5, Q6, etc., mientras menor sea la cuantización, menos VRAM se usa (Q4 ≒ parámetros/2, Q6 ≒ parámetros*0.75). Aun así, hay que considerar la posible pérdida de calidad
- Cálculo de VRAM necesaria: por ejemplo, 8B Q4 requiere 4GB, 14B Q4 requiere 7GB y 30B Q4 necesita alrededor de 15GB de VRAM
- Offloading a RAM: si falta VRAM, algunas capas pueden enviarse a memoria de CPU. Eso sí, hay que aceptar una caída de velocidad
- Cuantización de KV cache: al ampliar la context window, se recomienda comprimir la caché con algo como q4
Herramientas y frontends
- llama.cpp: funciona rápido y con flexibilidad en varias plataformas. Soporta API REST y un frontend sencillo en React. Puede cargar modelos repartiendo entre VRAM y RAM
- Ollama: instalación sencilla y cambio fácil entre modelos, además de buena integración con frontends GUI. Sin embargo, tiene límites en soporte de modelos recientes y tamaño de contexto
- LM Studio: cómodo para gestionar modelos en entorno GUI. Incluye una función para predecir si un modelo cabe en la VRAM disponible
- OpenWebUI: solo frontend. Requiere un backend como llama.cpp o vllm. Permite gestionar y probar varios modelos al mismo tiempo
- KoboldCPP, SillyTavern: frontends especializados para roleplay, storytelling y juegos
Comunidad e información práctica
- Reddit LocalLLaMA, HuggingFace, Discord: ahí se comparten activamente novedades de modelos, guías de uso, benchmarks y consejos de configuración. Aun así, hay que cuidarse de la desinformación y del groupthink
- Sitios de benchmarks: livebench.ai, aider.chat y otros ofrecen puntajes y rankings actualizados por modelo
Objetivos de uso y experiencia real
- Privacidad y ahorro de costos: para datos sensibles, temas de privacidad o uso repetitivo, los modelos locales suelen ser más convenientes que la nube
- Libertad para experimentar y ajustar: ofrecen más flexibilidad que los modelos por API en fine-tuning por dominio, estrategias de sampling y prompt engineering
- Casos de uso: hay ejemplos prácticos como RAG (generación aumentada por búsqueda), integración con bases de datos locales, automatización con agentes y asistentes offline
Preguntas y consejos frecuentes
- Cálculo del tamaño del modelo: número de parámetros × bits (quantization) / 8 = requerimiento aproximado de VRAM (GB). También hay que considerar el overhead y la context window
- Características por modelo: Qwen3 para reasoning/código, Gemma3 para intuición/conversación, Mistral con menos censorship, y Dolphin/abliterated como versiones uncensored, entre otros
- Comparación de rendimiento: se recomienda hacer benchmarks y pruebas personalizadas para encontrar el modelo que mejor se adapte a cada caso
Conclusión y consejo práctico
- No existe un "mejor modelo" universal; lo más recomendable es probar distintos modelos recientes de 8B~14B como Qwen3, Mistral y Gemma3 según el hardware, el uso y las preferencias
- Como el tamaño del archivo del modelo, la cuantización y el tamaño de contexto son muy importantes, lo más efectivo es probar varios modelos directamente y apoyarse en consejos de la comunidad
1 comentarios
Opinión de Hacker News
Si quieres ejecutar un LLM en local, puedes encontrar mucha ayuda en la comunidad localllama de reddit
No existe un modelo LLM que pueda llamarse específicamente el "mejor"; como cada modelo tiene ventajas y desventajas, hay que probar varios por cuenta propia
Por ejemplo, hoy se lanzó el modelo DeepSeek-R1-0528-Qwen3-8B, y muestra el mejor rendimiento de razonamiento lógico en el tamaño 8B
Y la serie Qwen3 también salió hace poco, ofreciendo un enfoque híbrido, buen rendimiento y varios tamaños para distintos tipos de hardware
Qwen3-30B-A3B puede correr a una velocidad aceptable incluso en CPU
Incluso el mini modelo de 0.6B es sorprendentemente consistente
Al usar llama-cpp, he visto casos donde descargar algunos tensores al CPU permite mantener buen rendimiento
Normalmente en llama-cpp se especifica la cantidad de capas que se suben al GPU (
-ngl), pero si no se trata de tensores muy pesados en cómputo, moverlos al CPU puede ahorrar espacio en GPU sin perder velocidadTambién leí un paper sobre cargar solo las neuronas "hot" desde el CPU (enlace a arxiv), y me hace pensar que en el futuro podremos aprovechar la IA en casa de formas muy potentes
Una advertencia para quien no esté acostumbrado a usar Reddit
En Reddit, incluyendo LocalLlama, hay mucha desinformación y falsedades populares, y la proporción de upvotes/downvotes no garantiza la exactitud de la información
Un comentario correcto pero explicado de forma aburrida puede volverse impopular, mientras que explicaciones incorrectas pero divertidas, emocionales o alineadas con la opinión del grupo suelen ganar popularidad
Quienes llevamos mucho tiempo navegando por la web más o menos sabemos filtrar eso, pero si alguien llega por primera vez a espacios con pensamiento grupal tan fuerte, conviene tomar la información con cautela
Hoy en día casi cualquier modelo cumple con lo básico, así que al final se siente más como encontrar una "personalidad de modelo" que encaje con tus gustos
El OP simplemente debería ir descargándolos y probándolos uno por uno
Con 16GB de memoria, usando llama.cpp con offload parcial a DDR5 puedes correr modelos de hasta 30B (incluso modelos dense) a una velocidad "razonable"; con offload de tensores, todavía mejor
Qwen tiene algunos puntos flojos como modelo conversacional
Mistral Nemo, Small y la serie Llama 3.X siguen siendo excelentes opciones a día de hoy
Gemma 3s es bueno, aunque algo impredecible
Si quieres algo del nivel de GPT-4 en casa, recomiendo QwQ
Y seguro hay más modelos buenos que se me están olvidando
Me pregunto si hay algún modelo recomendable para usar con herramientas de programación como aider o roo
Mi experiencia es que encontrar un modelo que use herramientas bien por sí solo es bastante difícil
DeepSeek-R1-0528-Qwen3-8B es un modelo creado destilando el chain-of-thought de DeepSeek-R1-0528 en Qwen3-8B Base; en AIME 2024 rinde más de un 10% por encima de Qwen3-8B y alcanza un nivel similar a Qwen3-235B-thinking
Es uno de esos casos que vuelve a sorprender por lo efectiva que puede ser la distillation
Probablemente por eso varias empresas y laboratorios de IA están ocultando el chain-of-thought (COT) últimamente (referencia)
Me da curiosidad para qué usa más la gente los LLM locales
A menos que el hardware sea muy bueno, es difícil igualar modelos propietarios como Gemini o Claude, así que aunque estos modelos pequeños sin duda parecen útiles, me interesa saber casos de uso concretos
La incomodidad de entregar datos a terceros
Hay mucha gente que simplemente no quiere enviar sus prompts o preguntas a servicios externos
Yo primero pruebo un modelo local para la mayoría de mis prompts, y para mi sorpresa en más de la mitad de los casos obtengo resultados suficientemente buenos
Cada vez que logro no usar un servicio en la nube me da cierta satisfacción
Creo que el futuro de los LLM locales será decidir con rapidez qué tarea procesar y cómo delegarla de forma igual de rápida
Algo que sepa distinguir si una tarea puede resolverse con un sistema local como MCP, si requiere llamadas a APIs del sistema como calendario o correo, o si conviene enviarla al mejor modelo en la nube
Me imagino algo como una Siri que realmente funcione bien
Ahora mismo estoy experimentando con un agente local de programación que armé yo mismo sobre Devstral
Lo que me gusta más frente a Codex es que tiene acceso completo al hardware, así que puede levantar VMs, hacer solicitudes de red y realizar tareas que Codex no puede
Además, desde la configuración inicial hasta la generación de parches, es mucho más rápido que Codex
Claro, todavía no alcanza el nivel de resultados de Codex, pero Devstral sirve bien para cambios pequeños o refactors, y espero que conforme evolucione el software pueda encargarse también de cambios más grandes
Yo, por principio, evito la nube siempre que puedo
Por ejemplo, hace poco salió la noticia de que OpenAI incluso está trabajando en una especie de red social para compartir conversaciones de ChatGPT
Al correr todo en local también entiendes mejor cómo funciona por dentro la IA, lo que además aumenta tu valor en el mercado
También te da libertad para experimentar con backends de LLM (búsqueda web, agentes, etc.), no tienes costos de nube y además yo ya tenía una desktop gamer desde que salió LLaMa por primera vez
También vale la pena seguirle la pista a LocalScore, un proyecto de Mozilla
Es un servicio que compara y analiza qué tan bien corren distintos modelos en varios tipos de hardware
Coincido con la recomendación del subreddit LocalLLama
No es que elija por ti el "mejor modelo", pero ayuda muchísimo para hacer preguntas, encontrar guías, enterarte de novedades y herramientas, y comparar modelos distintos
Al final se trata de que tú mismo pruebes varios modelos y ajustes parámetros hasta encontrar el que mejor se adapta a tu objetivo
Si eres usuario de Hacker News, quizá también valga la pena considerar saltarte Ollama o LMStudio
Puede costar más acceder a modelos recientes, y muchas veces terminas eligiendo solo entre los modelos que ellos ya probaron
Además, se pierde un poco la diversión de "abrir la tapa" y ver cómo funciona por dentro
Solo con llamacpp ya tienes soporte para la mayoría de los modelos recientes, y si hace falta se actualiza rápido
Prefiero descargar modelos desde huggingface y usar formato GGUF (cuantización baja para ahorrar memoria)
Viendo el tamaño del archivo GGUF puedes darte una idea aproximada de si cabrá en VRAM (por ejemplo: un GGUF de 24GB es demasiado para 16GB; uno de 12GB sí cabe, aunque si subes el context también sube el uso de RAM)
También hay que prestar atención a la ventana de contexto: muchos modelos viejos son de 8K de contexto, y aunque los configures a 32K no siempre mejora mucho
llamacpp ofrece binarios para Linux, Windows y macOS, o puedes compilarlo tú mismo, y también permite dividir el modelo entre VRAM y RAM
Incluye un frontend React sencillo (
llamacpp-server) y también una API REST similar a la de OpenAIPor eso se integra con varios frontends como oobabooga (textgeneration webui)
Si llamacpp te parece muy rústico, Koboldcpp puede ser una opción de backend a considerar (aunque por dentro sigue basado en llamacpp)
Una ventaja atractiva de Ollama es que puede descargar directamente cualquier GGUF desde HuggingFace y correrlo con algo como
ollama run hf.co/unsloth/DeepSeek-R1-0528-GGUF:Q8_0Una de las ventajas de Ollama es que permite cargar y descargar modelos en GPU fácilmente, así que en frontends como librechat u openwebui puedes cambiar de modelo desde un simple menú desplegable
Quiero destacar lo cómodo que es poder cambiar de modelo sin tocar la línea de comandos
Ollama convierte tu desktop en un servidor LLM, accesible incluso desde dispositivos remotos por WiFi
También permite cambiar de modelo de forma fluida sin bajar el servidor
En llama.cpp, en cambio, desde la CLI normalmente hay que bajar el servidor, volver a lanzarlo con otros flags y luego levantarlo otra vez, lo que es incómodo para experimentar o desarrollar apps rápido
Incluso tengo apps donde es indispensable poder cambiar entre modelos 1B, 8B o 30B usando solo un parámetro en la solicitud web, sin reiniciar el servidor
Aunque solo tengo 8GB de VRAM, conecté OpenWebUI como frontend de Ollama para cargar varios modelos al mismo tiempo y probarlos en round robin
Así también puedo monitorear continuamente la calidad de las respuestas y decidir con el tiempo qué modelo se adapta mejor a mi propósito
OpenWebUI ofrece una experiencia de uso bastante particular
Como usuario de una AMD 6700XT (12GB de VRAM), una vez que logré configurar ROCm en local, pude correr Ollama con aceleración por GPU sin problemas
Conectar una instancia de OpenWebUI levantada en Docker con mi servidor local de Ollama fue tan simple como definir una variable de entorno
No es producción sino un entorno personal de pruebas, pero para el objetivo descrito arriba funciona muy bien
Vale la pena saber que OpenWebUI, tras un cambio reciente de licencia, ya no es open source
La familia Qwen3 (y el distill R1 qwen3-8b) está en primer lugar en programación y razonamiento lógico
Eso sí, por venir de China tienen una censura fuerte en temas políticos
Para conocimiento general del mundo e información reciente, recomiendo Gemma3
Es muy probable que este post quede obsoleto en un mes, así que conviene revisar benchmarks actualizados en livebench.ai o el leaderboard de aider.chat
No solo evolucionan los modelos, también las herramientas, routers, MCP, librerías y SDKs
Si desarrollas por tu cuenta y no tienes colegas o una comunidad cercana con quien intercambiar información, hace falta algún consejo para aprender y seguir las tendencias actuales
La mejor fuente de información es HuggingFace
La serie Qwen rinde bien en varios frentes, y recomiendo el modelo Qwen/Qwen3-14B-GGUF Q4_K_M
Solo usa unos 7-8GB de VRAM, así que no pesa mucho, y recomiendo usar llama-server o LM Studio
Llama 3.3 también es una buena opción
Devstral es demasiado grande, así que solo vale la pena intentarlo en versión cuantizada
Gemma rechaza muchas cosas, pero sirve para objetivos específicos como Medgemma
Los modelos “Uncensored” Dolphin de Eric Hartford y los modelos abliterated son recomendables si necesitas un modelo con pocas restricciones para tareas como generar chistes o trabajos relacionados con seguridad o defensa (para uso diario no son indispensables)
Con dtype bf16, el tamaño de un modelo sin cuantizar se calcula como número de parámetros x2
Si usas un modelo cuantizado Q4_K_M (4 bits), el requerimiento de VRAM es aproximadamente la mitad del número de parámetros
También hay que considerar overheads como activaciones, así que conviene empezar probando modelos bastante por debajo de 16GB
llama-server incluye GUI y también permite descargar modelos con la opción
-hfLM Studio también facilita la instalación y administración de modelos
Si quieres respuestas rápidas, conviene levantar el servidor una sola vez y reutilizar el modelo para múltiples consultas (si recargas el modelo en cada pregunta será lento)
En 16GB, Mistral Small 3.1 en Q4 quant o Qwen3-14B en FP8 corren bastante bien sin demasiadas complicaciones
Eso sí, según el uso de VRAM, al trabajar con context length largos Qwen3-14B en Q4 quant rinde peor que FP8, pero deja más margen de memoria
Mistral Small soporta entrada de imágenes, mientras que Qwen3 está más especializado en matemáticas y código
No recomiendo bajar de Q4 porque la eficiencia cae
Si tu prioridad es contexto largo, quizá convenga más Qwen3-8B en Q4 quant, y Qwen3-30B-A3 parece quedarse un poco corto para 16GB de VRAM (los modelos pesados ocupan más de 15GB en GGUF)
Los modelos dense (usan todos los parámetros) tienen mejor rendimiento por parámetro que los modelos sparse, aunque son más lentos; con una GPU clase 5060, 14B se mueve con bastante comodidad
Si tienes arquitectura Blackwell, los modelos cuantizados en NVFP4 son más rápidos que FP8, aunque con una pérdida mínima de calidad; como ollama todavía no los soporta, necesitarías usar vLLM por separado
Como hay poco soporte para modelos NVFP4 pre-cuantizados, se recomienda cuantizarlos tú mismo con herramientas como llmcompressor
Lo mejor es elegir primero el LLM que quieres y usar este tipo de herramientas solo cuando ya toque optimizar el rendimiento
Es casi imposible dar una respuesta objetiva y clara sobre los LLM; lo más importante es probar tú mismo varios modelos recientes en tareas que te importen
Según el tipo de trabajo, la calidad de los resultados puede variar muchísimo
A menudo me pregunto cómo estima la gente el uso de VRAM
En la información descargable de modelos como los archivos gguf no suele indicarse claramente el requerimiento de VRAM o memoria, y eso se extraña
Como regla muy aproximada, puedes pensar que la cantidad de parámetros (en B) equivale a memoria en GB
Ejemplos según cuantización:
FP16 = 2 x 8GB = 16GB (modelo de 8B)
Q8 = 1 x 8GB, Q4 = 0.5 x 8GB = 4GB
En la práctica cambia un poco, pero no suele alejarse demasiado, y además necesitas memoria extra para cosas como la longitud de contexto
La lógica base es cantidad de valores float x número de bits del tipo de dato (4, 8, 16...)
Además de la cuantización, si quieres calcular con más precisión cosas como la KV cache, recomiendo usar esta calculadora de VRAM