En este episodio continuo explorando este ChatGTP personalizado que es OpenWebUI, y que te permite hacer casi cualquier cosa que puedas imaginar. En concreto me he centrado únicamente en dos aspectos concretos. Los prompts y los modelos. Lo que realmente ando buscando es tener las herramientas que necesito directamente en mi entorno de trabajo sin tener que recurrir a un servicio de terceros. Vamos lo que venimos llamando soberanía digital. Sin embargo, no quiero perder ninguna de las características que tengo con Gemini o con Google AI Studio, e incluso mejorarlas con las opciones que me ofrece OpenWebUI. Durante estos últimos días he estado probando decenas de distintos modelos, y los resultados eran dispares. Incluso modelos como Gemma4 no se comportaba como yo esperaba. Hasta que me he dado cuenta de un detalle fundamental, la ventana de contexto. En ocasiones utilizo prompts tan extensos que se comían literalmente la ventana de contexto. Así en este episodio vamos a abordar modelos y prompts, incluso la opción de crear tus propios modelos.
En busca del mejor modelo
Buscando modelos
En los episodios anteriores estuvimos hablando de hardware y de modelos. ¿Pero que modelo encaja en tu hardware?. En este sentido te hablé de rust-hf-downloader, que es una herramienta que te permite descargar modelos desde Hugging Face, y que te muestra información sobre el modelo, como su tamaño, su ventana de contexto, etc. Sin embargo, no es una herramienta que te permita gestionar los modelos que tienes en tu entorno de trabajo.
Pero además en el grupo de Telegram Juanma comentó que utilizaba llfit, que es una herramienta que te permite realizar búsquedas de los modelos soportados en tu equipo. Esta herramienta selecciona el modelo mas adecuado en base a tu RAM, CPY y GPU. Además todo lo hace de forma interactiva y muy sencillo.
Un poquito de background
Entender la ventana de contexto (el «espacio de memoria» a corto plazo del modelo) es vital. Si te pasas, el modelo empezará a «olvidar» el principio de la conversación. Cada modelo de lenguaje tiene un límite físico definido durante su entrenamiento (y configurado en su Modelfile). En Ollama, este valor se suele definir con el parámetro num_ctx. Por defecto, si no se especifica, Ollama suele arrancar muchos modelos con un contexto de 2048 o 4096 tokens, aunque el modelo soporte más (como Llama 3 que llega a los 8k o más). Y claro, si te pasas con el prompt, evidentemente esto lo pierdes por completo. Y como andaba jugando en paralelo tanto con modelos como con prompts…
Descubriendo las ventanas de contexto
Actualmente estoy utilizando Ollama como mi servidor de modelos, así que hay que preguntarle por esta información, y lo puedes hacer de dos formas, o bien directamente con,
ollama show gemma4:latest --parametersO bien vía API,
curl -s http://localhost:11434/api/show -d '{"name": "gemma4:latest"}' | jq '.parameters'Como te decía, dado que estuve probando varias decenas de modelos, finalmente me decidí por un script que me mostrara de forma ordenada los modelos que tengo en mi Ollama, y sus respectivas ventanas de contexto. Y el resultado es el siguiente,
ACTUAL MÁXIMO MODELO
------ ------ ------
64000 262144 Qwen3-4B-Instruct-2507-Q4_K_M:latest
64000 163840 DeepSeek-V2-Lite-Chat-Q4_K_M:latest
96000 131072 gemma4-128k:latest
4096* 262144 zantag/Qwen3-30B-A3B-Thinking-2507-GGUF-Q2_K_XL:latest
4096* 131072 granite3.3:latest
131072 262144 batiai/qwen3.5-9b:q6
4096* 131072 deepseek-r1:8b
4096* 512 nomic-embed-text-v2-moe:latest
4096* 262144 qwen3.5:27b
4096* 262144 qwen3.5:9b
4096* 262144 qwen3.5:4b
4096* 262144 qwen3.5:0.8b
8192 2048 nomic-embed-text:latest
65536 1010000 myaniu/qwen2.5-1m:14b
65536 1010000 myaniu/qwen2.5-1m:7b
4096* 131072 mma4:e2b
4096* 16384 motron-3-nano:4b
4096* 262144 mma4:latest
4096* 131072 mma4:e4b
4096* 32768 mistral:7bLo cierto es que no me había dado cuenta de este detalle, y es que algunos modelos, como Gemma4 o Qwen3-4B tienen una ventana de contexto de 128k o 256k tokens, pero Ollama los estaba arrancando con una ventana de contexto de tan solo 4096 tokens. Esto evidentemente hacía que los resultados fueran muy pobres, y no se comportaran como yo esperaba. Así que lo primero que hice fue configurar la ventana de contexto a su valor máximo, y el resultado fue espectacular. De hecho, el modelo Gemma4 se comporta ahora como yo esperaba, y es una auténtica pasada. Evidentemente esto no es algo que puedas hacer con un modelo alojado en un servicio de terceros, pero al tenerlo en tu propio entorno de trabajo, puedes configurarlo a tu antojo.
Modificar la ventana de contexto
Tienes varias opciones para modificar la ventana de contexto, o bien directamente con el comando ollama run, o bien modificando el Modelfile del modelo. En mi caso, dado que quiero que el modelo siempre arranque con la ventana de contexto al máximo, he optado por modificar el Modelfile. Para ello, lo primero que hice fue localizar el Modelfile del modelo, y luego modificar el valor del parámetro num_ctx a su valor máximo. En el caso de Gemma4 lo he configurado a 131072 tokens, y el resultado ha sido espectacular.
Dado que he estado importando también modelos de Hugging Face, he implementado un sencillo script que me permita integrar el modelo dentro de Ollama definiendo además la ventana de contexto.
Y por supuesto, y como no podía ser de otra forma, otro script adicional que me permite crear un nuevo modelo a partir de uno existente. Que conste, que todas estas operaciones o muchas de ellas se pueden realizar desde la interfaz de OpenWebUI, pero como me gusta más la terminal, pues he optado por esta opción.
Cuanto consumo la ventana de contexto
El contexto se almacena en lo que llamamos el KV Cache (Key-Value Cache). Este espacio reside en la VRAM de tu GPU (o en la RAM si usas CPU).
La fórmula rápida para modelos de 7B a 9B (como tus Qwen o DeepSeek):
- Cada 1.000 tokens de contexto extra consumen, aproximadamente, entre 50 MB y 100 MB de VRAM adicional (dependiendo de la cuantización).
- Si subes a 32.000 tokens, prepara unos 2 GB – 3 GB de VRAM solo para la «memoria» del modelo, aparte de lo que ya pese el modelo en sí.
- Si te vienes arriba y pones los 262.144 tokens del Qwen 3.5, ¡podrías necesitar más de 20 GB de VRAM solo para el contexto!
Entonces, ¿Cuanta ventana de contexto utilizo?
No por tener 1 millón de tokens de máximo hay que usarlos siempre. La recomndación,
- Uso diario (Chat/Asistente): Configura tus modelos a 8.192 o 16.384 tokens. Es más que suficiente para recordar el hilo de una conversación larga y el modelo responderá a la velocidad del rayo.
- Programación (Análisis de archivos): Súbelo a 32.768. Te permite meterle un par de clases de Rust o scripts de Fish enteros para que los entienda en bloque.
- Análisis de Documentación/Libros: Solo ahí, usa los modelos de 1M (millón) como el
qwen2.5-1m, pero asegúrate de tener RAM de sobra.
El equilibro de poder von la VRAM, teniendo en cuenta que se dvidie en dos partes,
- El peso del modelo, o lo que es lo mismo, lo que pesa el cerebro en reposo.
- KV Cache. El espacio para la memoria de trabajo.
Para maximizar el contexto con 16 GB, la mejor estrategia es usar modelos de 7B a 9B parámetros con una cuantización de 4-bit o 5-bit (Q4_K_M o Q5_K_M).
- Un modelo de 9B (como Qwen 3.5) a Q4 ocupa unos 5.5 GB.
- Te quedan 10.5 GB libres.
- Esos 10.5 GB pueden albergar aproximadamente 64.000 tokens con total seguridad, y quizás llegar a 96.000 forzando un poco.
Así puedo crear dos versiones personalizadas, una para razonamiento profundo, DeepSeek, y la otra para memoria masiva con Qwen
FROM deepseek-r1:8b
PARAMETER num_ctx 32768FROM qwen3.5:9b
PARAMETER num_ctx 65536
PARAMETER num_predict 4096¿Y qué pasa con los modelos de 14B o 30B?
Con 16 GB de VRAM:
- Un 14B (como DeepSeek-R1 14B) ocupa unos 9-10 GB. Te deja sitio para unos 16k-24k de contexto.
- Un 30B (como el Qwen que tienes en Q2) ocupa unos 12-13 GB. Estás muy al límite; te recomiendo no pasar de 8k de contexto para evitar que el sistema se vuelva inestable.
Usa el Qwen 3.5 9B configurado a 64k. Es el punto donde la inteligencia del modelo y la capacidad de memoria se encuentran en un equilibrio perfecto para tu hardware. Podrás analizar hilos de conversación larguísimos sin que la GPU sufra.
Un contexto de 4096 tokens ¿para que da?
En modelos basados en arquitecturas tipo Llama o Gemma, la equivalencia aproximada es 1.000 tokens ≈ 750 palabras (en inglés) / ≈ 600-700 palabras (en español). El español consume un poco más de tokens por la cantidad de artículos, flexiones verbales y caracteres especiales (tildes, eñes). Haciendo cálculos rápidos,
- Palabras: Unas 2.800 – 3.000 palabras.
- Páginas (A4, espacio simple): Unas 5 o 6 páginas de texto denso.
- Tiempo de lectura: Unos 10-12 minutos de lectura en voz alta.
Sin embargo, en todo esto hay una pequeña trampa. Esos 4.096 tokens no son solo para tu pregunta, son para TODO lo que el modelo tiene que tener en mente en ese instante. El pastel se reparte de la siguiente forma,
- System Prompt (Instrucciones): Si le has dicho «Eres un experto programador en Rust, amable, directo…», eso ya gasta tokens.
- Historial de la conversación: Para que la IA recuerde lo que dijiste hace tres mensajes, tiene que volver a leer esos mensajes en cada turno.
- Tu pregunta actual: Lo que acabas de escribir.
- La respuesta de la IA: Los tokens que está generando ahora también cuentan dentro del límite.
Conclusión: Si tienes una conversación larga, en el momento en que la suma de (Instrucciones + Historial + Pregunta + Respuesta) llegue a 4.096, el modelo empezará a olvidar el principio. Es el efecto borrachera, la IA sigue hablando, pero ya no sabe de qué habláis al principio.
Para que lo veas claro en tu día a día con Linux y el desarrollo:
- DA PARA (OK ✅):
- Explicar un script de Fish de unas 100 líneas.
- Resumir un artículo de un blog o una noticia.
- Ayudarte a redactar un correo electrónico profesional.
- Resolver errores de compilación de un solo archivo.
- NO DA PARA (MAL ❌):
- Analizar un archivo
docker-compose.ymlcomplejo junto con sus 5Dockerfileasociados. - Pegar un log de sistema (
journalctl -u podman) de los últimos 10 minutos. - Pedirle que refactorice una clase de Rust de 500 líneas.
- Mantener una sesión de «brainstorming» de dos horas sobre un proyecto.
- Analizar un archivo
- 4.096 tokens: Una servilleta de restaurante (útil para una nota rápida).
- 128.000 tokens (Tu Gemma 4): ¡Un libro de 300 páginas!
Más información,