Encontré 42 GB de modelos de IA fosilizados en mi PC: una puesta al día honesta sobre IA local, conceptos y entornos Python en 2026

Hace tiempo que no tocaba nada de IA en mi PC, y al echar un ojo descubrí varios programas que no recordaba para qué eran y, sobre todo, modelos de hace año y medio acumulando polvo en el disco. Lo que empezó como una limpieza acabó siendo una puesta al día completa: Ollama, conceptos fundamentales, mapa del ecosistema, comparativas, y un setup de Python desde cero. Lo dejo aquí ordenado por si a alguien le sirve.

1. El punto de partida: 42 GB de modelos zombi

Lo primero que encontré fue Ollama corriendo en segundo plano (ese icono pequeño en la barra de tareas que llevaba meses sin tocar). Un ollama list reveló cinco modelos descargados hacía 18 meses, ocupando casi 42 GB:

• llama-3-8B-programming-questions — 16 GB
• SuperNova-Medius-Q8_0 — 15 GB
• uncensored_wizard_7b — 4.1 GB
• llama3.2 — 2 GB
• llama3.1 — 4.7 GB

En el mundo de la IA, 18 meses son una eternidad. Han salido Llama 3.3 y 4, Qwen 2.5 y 3, DeepSeek-V3 y R1, Gemma 3 y 4, gpt-oss... cualquiera de los nuevos rinde mejor que esos modelos viejos. Conclusión rápida: borrar todos.

ollama rm llama-3-8B-programming-questions:latest SuperNova-Medius-Q8_0:latest uncensored_wizard_7b:latest llama3.2:latest llama3.1:latest

De paso descubrí que mi Ollama estaba en la versión 0.9.0 cuando la actual rondaba la 0.23.x. Tras actualizar, me encontré con una app de escritorio renovada: chat integrado (ya no hace falta terminal ni Open WebUI), una sección "Launch" para integrar agentes externos como Claude Code o Codex CLI, y settings con opciones de modelos en la nube y configuración de contexto.

2. Los tres niveles que casi nadie distingue: modelo, motor, interfaz

Antes de seguir con elecciones técnicas, conviene tener claro un mapa mental que mucha gente confunde:

1. El modelo son los pesos entrenados — un fichero (o conjunto de ficheros) muy grande lleno de números. Es el "cerebro" estático. Ejemplos: Llama 3.3, Qwen 3, DeepSeek-R1, Gemma 3.
2. El motor de inferencia es el programa que carga ese fichero y lo ejecuta. Hace los cálculos, gestiona la VRAM, aplica la cuantización. Sin motor, el modelo es un archivo muerto. Ejemplos: llama.cpp, vLLM, MLX, TensorRT-LLM.
3. La interfaz es lo que tú usas para hablar con todo lo anterior: una terminal, una app de chat, una API, un editor de código.

Ollama es las tres capas empaquetadas: motor (basado en llama.cpp), interfaz de chat, y catálogo curado de modelos.

Una buena analogía: el modelo es como un MP3 (la canción grabada), el motor es el códec/reproductor que sabe decodificarlo, y la interfaz es la app con la que le das al play. Ollama sería como Spotify: trae las tres cosas juntas.

3. ¿Quién compite con quién? El mapa del ecosistema

"DeepSeek vs Gemini vs ChatGPT vs Ollama" es una frase que mezcla cosas de distinta naturaleza. La comparación honesta sería:

Capa	Competidores reales
Modelos cerrados de frontera	OpenAI (GPT), Anthropic (Claude), Google (Gemini), xAI (Grok)
Modelos abiertos de frontera	DeepSeek, Meta (Llama), Alibaba (Qwen), Mistral, Google (Gemma), Moonshot (Kimi)
Productos de chat al consumidor	ChatGPT, Gemini app, Claude.ai, Copilot, DeepSeek chat
Motores/plataformas locales	Ollama, LM Studio, llama.cpp, vLLM, MLX

El I+D real está en el modelo, no en el motor. Entrenar un modelo frontera cuesta entre 100 millones y más de 1.000 millones de dólares. Una vez entrenado, distribuirlo es prácticamente gratis. Esa asimetría — coste fijo enorme, coste marginal cero — es la economía rara que define este sector. Por eso OpenAI guarda sus pesos como secreto industrial y por eso cuando Meta o DeepSeek publican un modelo abierto, esa ventaja se democratiza para siempre.

4. Los muros del escalado: por qué energía infinita no bastaría

Aunque tuvieras energía ilimitada, hay límites antes:

• El muro de los datos: la internet pública útil es finita (~10-20 billones de tokens). Se estima que entre 2026 y 2028 se agota el stock de texto humano de calidad disponible para entrenamiento.
• Diminishing returns: las leyes de escalado son una ley de potencias. Reducir el error a la mitad requiere multiplicar el cómputo por ~10. Y existe una asíntota irreducible que no se baja por mucho cómputo que metas.
• Colapso del modelo: entrenar modelos sobre sus propios outputs (datos sintéticos) produce degradación matemáticamente demostrable: van perdiendo las "colas" de la distribución y convergen a un promedio cada vez más estrecho.
• Límites arquitectónicos: la atención del transformer es cuadrática respecto al contexto, y hay tareas donde añadir parámetros simplemente no ayuda.

Por eso la frontera real hoy se está jugando en mejor aprovechamiento de los datos existentes (técnicas tipo o3/R1 con razonamiento explícito) y en arquitecturas alternativas, no solo en "más GPUs".

5. Cerebro humano vs IA: ni iguales ni opuestos

Brevemente, porque da para post aparte. Diferencias clave:

• El cerebro aprende continuamente; un LLM se entrena una vez y se congela.
• Tu cerebro funciona con 20 vatios; entrenar GPT-4 consumió decenas de gigavatios-hora.
• Un niño aprende "gato" con 3 ejemplos; un modelo necesita millones.
• El cerebro es encarnado: aprendió moviéndose en un mundo físico.
• El cerebro tiene memorias múltiples (de trabajo, episódica, semántica, procedimental); un LLM tiene pesos + ventana de contexto.

Pero hay paralelos sorprendentes: la corteza también predice constantemente lo que viene a continuación (predictive processing), las representaciones son distribuidas en ambos sistemas, y las redes convolucionales formaron espontáneamente jerarquías parecidas a la corteza visual sin que nadie se lo pidiera.

6. Hugging Face, GGUF, cuantización: cómo funcionan los modelos por dentro

Hugging Face es el "GitHub de los modelos de IA" — la plataforma donde investigadores y empresas suben sus modelos. Un modelo en formato bruto suele venir en safetensors (PyTorch) en precisión fp16 (16 bits por peso). Para Llama 3.1 8B son ~16 GB.

GGUF es el formato optimizado para inferencia eficiente, inventado por la comunidad de llama.cpp. Un único fichero con pesos + tokenizador + config + metadatos.

La cuantización es el truco que permite correr estos modelos en hardware doméstico: representar cada peso con menos bits. Tabla aproximada para un modelo 8B:

Cuantización	Bits/peso	Tamaño	Calidad
fp16 (sin cuantizar)	16	~16 GB	100%
Q8_0	8	~8.5 GB	~99%
Q4_K_M (estándar)	4	~4.7 GB	~95%
Q3_K_M	3	~3.7 GB	~88%
Q2_K	2	~2.7 GB	~70% (canta)

Q4_K_M es el "sweet spot" que casi todo el mundo usa.

Ollama te ahorra todo el proceso: descargar safetensors → convertir a GGUF → cuantizar → configurar llama.cpp → arrancar servidor HTTP → escribir cliente. Lo encapsula en un comando: ollama pull qwen3:32b.

7. ¿Qué merece la pena correr en local si ya tienes Claude Pro?

Honestidad cruda: para chat general, programación, razonamiento, escritura — Claude Pro le pasa por encima a cualquier modelo abierto que corras en local. Montarte un Qwen 32B para hacer peor lo mismo es un acto geek, no de utilidad.

Lo que sí merece la pena en local es lo que Claude no puede hacer:

• Generación de imágenes con FLUX o Stable Diffusion vía ComfyUI. Una RTX 4090 los mueve sin sudar. Sin cuotas, sin moderación, sin pagar por mes.
• Transcripción de audio con Whisper. Calidad de OpenAI sin pagar la API. Brutal para idiomas: transcribes podcasts en italiano y los analizas con Claude.
• Síntesis de voz con Piper, XTTS o Kokoro. Conviertes texto en audio, clonas voces, creas audiolibros.
• Voz conversacional en tiempo real (Moshi, Sesame). Ni Claude ni ChatGPT corren offline.
• Procesamiento masivo y privacidad: documentos sensibles, batch jobs que en API costarían cientos de euros.

Para LLMs locales puros, solo justifica si encajas en un nicho concreto: agentes que tocan muchos ficheros tuyos, autocompletado de código en el editor con latencia mínima, o uso offline.

8. Limpieza del entorno Python: fuera Anaconda, dentro Python 3.14

De paso, descubrí que tenía Anaconda instalado modificando mi PowerShell con (base) en cada arranque, y RStudio sin haber tocado R en años. Decisión:

• RStudio → desinstalar (no uso R).
• Anaconda → desinstalar. Aporta ~5 GB de librerías que no uso, ralentiza el arranque de la shell, y se mete en variables de entorno globales.
• Python → quedarme con la versión limpia de python.org, actualizada a 3.14.

Para actualizar Python desde línea de comandos en Windows:

winget install --id Python.Python.3.14 -e

Y luego desinstalar la versión vieja desde Aplicaciones (o con winget).

9. Conceptos limpios: pip, venv, uv

Pequeña aclaración que vale oro:

• pip es el instalador de paquetes que viene con Python.
• venv es un módulo de la librería estándar de Python que crea entornos virtuales — carpetas aisladas con su propia copia de Python y sus propios paquetes.
• uv es una herramienta externa moderna (escrita en Rust por Astral) que reemplaza a pip + venv + pyenv + poetry, todo en uno y mucho más rápido.

Para uso casual, pip + venv estándar bastan. uv tiene sentido cuando trabajas con muchos proyectos o te frustras con la lentitud de pip. No es necesario instalarlo preventivamente.

10. Hola Mundo limpio en venv

El flujo mínimo en PowerShell:

# Crear y entrar en el proyecto
mkdir holamundo
cd holamundo

# Crear el entorno virtual
python -m venv .venv

# Activarlo (verás (.venv) en el prompt)
.venv\Scripts\Activate.ps1

# Instalar un paquete (solo en este entorno)
pip install requests

# Ejecutar código
python hola.py

# Salir del entorno cuando termines
deactivate

El .venv se llama así por convención (las IDEs lo auto-detectan, los .gitignore lo excluyen por defecto). Cada proyecto tiene su propio .venv dentro de su carpeta — no se confunden entre sí porque viven en proyectos distintos.

Y un consejo de higiene: siempre añade un .gitignore con:

.venv/
__pycache__/

Conclusiones

• El ecosistema de IA local se mueve rápido. Si llevas más de un año sin tocarlo, probablemente todo lo que tienes está obsoleto.
• Distinguir entre modelo, motor e interfaz aclara muchas conversaciones que parecen confusas.
• Los modelos abiertos son ficheros estáticos — copiar es gratis, entrenar cuesta cientos de millones.
• Si ya pagas un buen servicio cloud (Claude Pro, ChatGPT Plus, Gemini), no tiene sentido instalar un LLM local "para hacer lo mismo". El valor del local está en lo que el cloud no hace: imágenes, audio, privacidad, batch.
• Anaconda fue útil hace 5 años; hoy hay alternativas más limpias (Python pelado + venv, o uv si quieres ir un paso más allá).
• Los entornos virtuales no son opcionales si vas a hacer Python en serio. Una sola convención (.venv dentro de cada proyecto) y se acaban los conflictos de dependencias para siempre.

Si tú también tienes un PC con software de IA fosilizado, ya tardas en hacer la limpieza.