Ir al contenido principal
PromptQuorumDiseñado para humanos. Estructurado para la IA.
Home/Local LLMs
Best Models

LLM locales con contexto largo 2026: modelos de 128K, 256K y 1M comparados

·10 min de lecturaPor · Fundador de PromptQuorum · Motor de descubrimiento de IA de pesos abiertos y código abierto

En 2026, 128K tokens es el nivel de entrada de los LLM locales, no el techo: Qwen3.5, Qwen3.8 y Gemma 4 (desde 12B) admiten 256K, NVIDIA Nemotron 3 Nano 30B admite 1M y Llama 4 Scout lista 10M. El límite real es la memoria: la caché KV a 128K ocupa desde unos 0.75 GiB (Nemotron 3 Nano) hasta 20 GiB (Mistral Small 3.2) según la arquitectura.

Key Takeaways

  • 256K es lo habitual y 1M es posible. Qwen3.5, Qwen3.8 y Gemma 4 (12B, 26B, 31B) listan ventanas de 256K en la biblioteca de Ollama. Nemotron 3 Nano 30B admite 1M. Gemma 4 E2B/E4B, Mistral Small 3.2, gpt-oss 20B y Llama 3.1 8B se quedan en 128K.
  • La caché KV decide la memoria y depende de la arquitectura. A 128K, la caché en f16 ocupa 16 GiB en Llama 3.1 8B, 8 GiB en Qwen3.8 27B, unos 2.7 GiB en Gemma 4 26B-A4B y unos 0.75 GiB en Nemotron 3 Nano.
  • Las arquitecturas híbridas abaratan las ventanas largas. La atención de ventana deslizante (Gemma 4, gpt-oss), Gated DeltaNet (Qwen3.5, Qwen3.8) y Mamba-2 (Nemotron 3 Nano) sustituyen muchas capas de atención completa, y solo las capas de atención completa crecen con la ventana.
  • Ollama usa por defecto 4K tokens por debajo de 24 GiB de VRAM, 32K entre 24 y 48 GiB y 256K desde 48 GiB. Define el contexto de forma explícita y compruébalo con ollama ps.
  • El contexto utilizable es más corto que el anunciado. RULER y NoLiMa encontraron caídas grandes de precisión a 32K en muchos modelos que anuncian 128K o más. Pon los datos críticos al principio o al final y prueba con tu longitud objetivo.
  • Elige según la tarea. RAG sirve para buscar en muchos documentos. El contexto largo sirve para razonar sobre un documento coherente, como un contrato, una base de código o un libro.

En 2026, 128K tokens es el nivel de entrada de los LLM locales; Qwen3.5, Qwen3.8 y Gemma 4 (desde 12B) admiten 256K y NVIDIA Nemotron 3 Nano 30B admite 1M, pero el límite práctico lo marca la memoria, no la ventana -- la caché KV en f16 a 128K va de 0.75 GiB a 20 GiB según la arquitectura.

La longitud de contexto indica cuánto texto puede leer un modelo en una sola petición. 128K tokens son unas 100,000 palabras y 256K unas 200,000 palabras. Las ventanas grandes cuestan memoria, y los modelos leen con menos fiabilidad la parte central de entradas muy largas, así que prueba con tus propios documentos antes de depender de una ventana larga.

En 2026, 128K tokens es el nivel de entrada de los LLM locales, no el techo. La biblioteca de Ollama lista ventanas de 256K para Qwen3.5, Qwen3.8 y Gemma 4 (desde 12B), 1M para NVIDIA Nemotron 3 Nano 30B y 10M para Llama 4 Scout. La memoria es el límite real: la caché KV a 128K ocupa desde menos de 1 GiB (Nemotron 3 Nano) hasta 20 GiB (Mistral Small 3.2) según la arquitectura, y Ollama usa por defecto solo 4K tokens en GPU con menos de 24 GiB de VRAM. Esta guía indica qué modelos admiten cada ventana, cuánta memoria cuesta cada una y cómo ajustar la longitud de contexto.

Slide Deck: LLM locales con contexto largo 2026: modelos de 128K, 256K y 1M comparados

La presentación siguiente cubre: qué LLM locales llegan a 128K, 256K y 1M tokens, la memoria de la caché KV por modelo a 32K, 128K y en la ventana máxima, por qué la arquitectura decide la memoria, la brecha entre contexto utilizable y anunciado (RULER, NoLiMa) y cómo ajustar num_ctx en Ollama. Descarga el PDF como tarjeta de referencia sobre LLM locales de contexto largo.

Browse the slides below or download as PDF for offline reference. Download Reference Card (PDF)

LLM locales con contexto largo 2026: modelos de 128K, 256K y 1M comparados

¿Qué es la longitud de contexto y por qué importa en los LLM locales?

La longitud de contexto es el número máximo de tokens que un modelo puede manejar en una sola petición: tu prompt, los documentos, la conversación hasta ese momento y la respuesta que escribe, todo sumado. Un token equivale a unas 0.75 palabras en inglés, así que 128K tokens son unas 100,000 palabras y 256K tokens unas 200,000 palabras.

La ventana anunciada es el máximo que admite la arquitectura del modelo. La ventana utilizable es la longitud a la que las respuestas siguen siendo precisas para tu tarea, y es más corta.

Las ventanas largas importan para bases de código completas, contratos, transcripciones largas, capítulos de libros y sesiones de agentes en las que se acumula la salida de herramientas. La documentación de Ollama recomienda al menos 64,000 tokens para agentes, búsqueda web y herramientas de programación.

Tres factores marcan el límite en tu propio equipo: la ventana del modelo, la memoria que necesita su caché KV a esa longitud y la fiabilidad con la que usa el texto a esa longitud. Las siguientes secciones tratan cada uno por turno.

¿Qué LLM locales admiten más de 128K tokens en 2026?

Varios: Qwen3.5, Qwen3.8 y Gemma 4 (desde 12B) listan ventanas de 256K en la biblioteca de Ollama, NVIDIA Nemotron 3 Nano 30B lista 1M y Llama 4 Scout lista 10M. Los modelos publicados antes de 2026 suelen quedarse en 128K.

La tabla muestra la ventana que indican la ficha del modelo o la biblioteca de Ollama. Una extensión de contexto, como YaRN, es una opción documentada por el fabricante que requiere configuración y memoria adicionales.

Llama 4 Scout lista 10M tokens, pero su ficha publica los benchmarks de contexto largo con una ventana de 128K, y la descarga de Ollama es de 67 GB. Llama 4 Maverick lista 1M, pero su descarga es de 245 GB, así que requiere hardware de servidor.

Las etiquetas de Ollama pueden diferir en el tamaño de ventana: qwen3:8b y qwen3:14b listan 40K, mientras que qwen3:4b y qwen3:30b listan 256K. Lee la cifra de contexto en la página de Ollama del modelo antes de planificar.

Modelo
Ventana listada
Contexto más largo
Etiqueta de Ollama
Nemotron 3 Nano 30B-A3B1M (por defecto 256K)—ollama run nemotron-3-nano:30b
Qwen3.8 27B256KHasta 1M (YaRN)ollama run qwen3.8:27b
Qwen3.5 9B / 27B256KHasta 1.01M (YaRN)ollama run qwen3.5:9b
Qwen3 30B-A3B-2507256K1M (DCA, ~240 GB GPU)ollama run qwen3:30b
Gemma 4 12B / 26B / 31B256K—ollama run gemma4:26b
Gemma 4 E2B / E4B128K—ollama run gemma4:e4b
Llama 4 Scout 109B10M listadosBenchmarks a 128Kollama run llama4:16x17b
Mistral Small 3.2 24B128K—ollama run mistral-small3.2
gpt-oss 20B128K—ollama run gpt-oss:20b
Llama 3.1 8B128K—ollama run llama3.1:8b
Qwen3 8B / 14B40K—ollama run qwen3:14b
Ventanas de contexto listadas de los LLM locales en escala logarítmica: 128K es el nivel de entrada, 256K es habitual, Nemotron 3 Nano admite 1M y Llama 4 Scout lista 10M.
Ventanas de contexto listadas de los LLM locales en escala logarítmica: 128K es el nivel de entrada, 256K es habitual, Nemotron 3 Nano admite 1M y Llama 4 Scout lista 10M.

¿Cuánta memoria necesita un contexto largo?

La memoria de un contexto largo son los pesos del modelo más la caché KV, y la caché KV depende de la arquitectura, no solo de la ventana. La caché KV guarda las claves y valores de atención de cada token del contexto y se reserva además de los pesos.

Bytes de KV por token = 2 (claves y valores) × capas de atención completa × cabezas KV × dimensión de cabeza × bytes por valor (2 en la caché f16 por defecto). Llama 3.1 8B: 2 × 32 × 8 × 128 × 2 = 131,072 bytes (128 KiB) por token, es decir, 16 GiB a 128K tokens, más de tres veces su descarga de 4.9 GB.

Las arquitecturas más recientes reducen este coste. Gemma 4 usa atención de ventana deslizante en la mayoría de las capas (ventana de 1,024 tokens en los modelos de 12B, 26B y 31B), gpt-oss en una capa de cada dos (128 tokens), Qwen3.5 y Qwen3.8 usan atención lineal Gated DeltaNet en tres de cada cuatro capas, y Nemotron 3 Nano solo tiene 6 capas de atención de 52. Solo las capas de atención completa crecen con la ventana.

Los valores siguientes se calculan a partir de la configuración publicada de cada modelo, no se han medido. Los entornos de ejecución añaden búferes de cálculo y las implementaciones de la caché difieren, así que confirma el uso real con ollama ps.

Cuantizar la caché KV la reduce: según la documentación de Ollama, q8_0 usa aproximadamente la mitad de la memoria de f16 y q4_0 aproximadamente una cuarta parte, con una pérdida de precisión de pequeña a media en q4_0.

Modelo
Descarga
KV a 32K
KV a 128K
KV a ventana máx.
Llama 3.1 8B4.9 GB4 GiB16 GiB16 GiB (128K)
Mistral Small 3.2 24B15 GB5 GiB20 GiB20 GiB (128K)
gpt-oss 20B14 GB0.8 GiB3 GiB3 GiB (128K)
Qwen3.5 4B3.3 GB1 GiB4 GiB8 GiB (256K)
Qwen3.5 9B6.6 GB1 GiB4 GiB8 GiB (256K)
Gemma 4 12B7.7 GB0.8 GiB2.3 GiB4.3 GiB (256K)
Gemma 4 26B-A4B16 GB0.8 GiB2.7 GiB5.2 GiB (256K)
Gemma 4 31B19 GB3.3 GiB10.8 GiB20.8 GiB (256K)
Qwen3.8 27B18 GB2 GiB8 GiB16 GiB (256K)
Qwen3.5 35B-A3B22 GB0.6 GiB2.5 GiB5 GiB (256K)
Qwen3 30B-A3B-250719 GB3 GiB12 GiB24 GiB (256K)
Nemotron 3 Nano 30B-A3B18 GB0.2 GiB0.8 GiB6 GiB (1M)
Pesos más caché KV en f16 con un contexto de 128K: Llama 3.1 8B necesita unos 21 GB, Qwen3.5 9B unos 11 GB y Nemotron 3 Nano unos 19 GB.
Pesos más caché KV en f16 con un contexto de 128K: Llama 3.1 8B necesita unos 21 GB, Qwen3.5 9B unos 11 GB y Nemotron 3 Nano unos 19 GB.

¿Qué modelo de contexto largo encaja en tu equipo?

Elige primero por memoria: los pesos más la caché KV al contexto que necesitas deben caber, con 2 a 3 GB de margen para el sistema operativo y el entorno de ejecución. Las propuestas siguientes son aritmética a partir de la tabla anterior, no clasificaciones de calidad; no hemos medido la precisión en contexto largo.

  • 8 GB: Qwen3.5 4B (descarga de 3.3 GB). La caché KV es de 1 GiB a 32K y 2 GiB a 64K; 128K necesita 4 GiB, lo que es justo en 8 GB.
  • 16 GB: Qwen3.5 9B (6.6 GB) cabe a 128K con unos 4 GiB de caché KV. Gemma 4 12B (7.7 GB) cabe en su ventana completa de 256K con unos 4.3 GiB.
  • 24 a 32 GB: Gemma 4 26B-A4B (16 GB) necesita unos 5.2 GiB a 256K. Qwen3.8 27B (18 GB) necesita unos 8 GiB a 128K. gpt-oss 20B (14 GB) necesita unos 3 GiB en su máximo de 128K.
  • 48 GB o más: Gemma 4 31B (19 GB) necesita unos 21 GiB a 256K. Mistral Small 3.2 24B (15 GB) necesita 20 GiB a 128K con caché f16 y unos 10 GiB con q8_0.
  • 1M tokens: según su configuración, Nemotron 3 Nano 30B necesita unos 6 GiB de caché KV a 1M además de su descarga de 18 GB, así que la memoria por sí sola no lo descarta en un equipo de 32 GB. NVIDIA entrega 256K por defecto y cita GPU H100 y A100 como hardware compatible, y Unsloth advierte de que 1M puede provocar cierres por falta de memoria, así que trátalo como un experimento. Qwen indica que 1M tokens con Qwen3-30B-A3B-Instruct-2507 necesitan unos 240 GB de memoria de GPU.

¿Por qué el contexto utilizable es más corto que el máximo anunciado?

La ventana anunciada es un límite superior de la arquitectura, no una garantía de calidad. Liu et al. (2023) comprobaron que los modelos de lenguaje responden con más precisión cuando el texto relevante está al principio o al final de la entrada y con menos precisión cuando está en el medio: el efecto «lost in the middle».

RULER (Hsieh et al., 2024) probó 17 modelos que anuncian 32K tokens o más; solo la mitad aproximadamente mantuvo un rendimiento satisfactorio a 32K. NoLiMa (Modarressi et al., 2025) probó 13 modelos que anuncian al menos 128K; a 32K, 11 de ellos cayeron por debajo del 50 % de su puntuación con contexto corto, y GPT-4o bajó de 99.3 % a 69.7 %.

Esos estudios son anteriores a la mayoría de los modelos de esta guía, así que léelos como evidencia del patrón, no como puntuaciones de ningún modelo citado aquí. Para comprobar un modelo tú mismo, esconde un dato al 10 %, 50 % y 90 % de un prompt largo, pregúntalo con otras palabras y repite a 32K, 64K y 128K.

Cuando la precisión importa, pon las instrucciones y los datos críticos al principio o al final del prompt, recupera solo los pasajes relevantes (consulta la sección de RAG más abajo) o procesa los documentos largos en secciones que se solapen.

Esquema del efecto «lost in the middle»: la precisión es más alta para la información al principio y al final del prompt y más baja en el medio (forma descrita por Liu et al., 2023; ilustrativo, no son valores medidos).
Esquema del efecto «lost in the middle»: la precisión es más alta para la información al principio y al final del prompt y más baja en el medio (forma descrita por Liu et al., 2023; ilustrativo, no son valores medidos).

¿Cómo se ajusta la longitud de contexto en Ollama, LM Studio y llama.cpp?

Ollama elige su contexto por defecto según tu VRAM: 4K tokens por debajo de 24 GiB, 32K entre 24 y 48 GiB y 256K desde 48 GiB. La entrada que supera el contexto activo se trunca, así que el modelo nunca ve el principio de un documento largo.

Puedes ajustar el contexto con el control deslizante de la app de Ollama, la variable de entorno OLLAMA_CONTEXT_LENGTH, /set parameter num_ctx dentro de ollama run, un Modelfile o la opción num_ctx de la API. Confirma el resultado con ollama ps.

En LM Studio, abre My Models, haz clic en el icono de engranaje de un modelo y ajusta el tamaño de contexto y Flash Attention. En llama.cpp, -c fija el tamaño de contexto (0 lo carga del modelo), -fa controla Flash Attention y --cache-type-k y --cache-type-v cuantizan la caché KV.

Ollama solo cuantiza la caché KV cuando Flash Attention está activado, y el ajuste es global para todos los modelos. OLLAMA_KV_CACHE_TYPE=q8_0 usa aproximadamente la mitad de la memoria de f16 y q4_0 aproximadamente una cuarta parte.

bash
# 1. Check what a loaded model really uses (see the CONTEXT column)
ollama ps

# 2. Server-wide default (the Ollama app has a context slider instead)
OLLAMA_CONTEXT_LENGTH=65536 ollama serve

# 3. One interactive session
ollama run qwen3.5:9b
>>> /set parameter num_ctx 65536

# 4. A persistent custom model
cat << EOF > Modelfile
FROM qwen3.5:9b
PARAMETER num_ctx 131072
EOF
ollama create qwen3.5-9b-128k -f Modelfile
ollama run qwen3.5-9b-128k

# 5. Optional: shrink the KV cache (global setting, needs Flash Attention)
OLLAMA_FLASH_ATTENTION=1 OLLAMA_KV_CACHE_TYPE=q8_0 ollama serve

# llama.cpp equivalent
llama-server -m model.gguf -c 131072 -fa on --cache-type-k q8_0 --cache-type-v q8_0
Formas de ajustar la longitud de contexto en Ollama, desde el valor por defecto del servidor hasta cada petición, y cómo verificar el valor activo con ollama ps.
Formas de ajustar la longitud de contexto en Ollama, desde el valor por defecto del servidor hasta cada petición, y cómo verificar el valor activo con ollama ps.

¿Los documentos en otros idiomas consumen más ventana de contexto?

Pueden hacerlo: Petrov et al. (2023) comprobaron que el mismo texto puede necesitar hasta 15 veces más tokens en un idioma que en otro, según el tokenizador. Que el texto en japonés, chino, coreano o árabe se vea afectado depende del tokenizador del modelo.

No conviertas páginas a tokens con la regla inglesa de 0.75 palabras por token. Cuenta los tokens con el modelo que vas a usar: ollama run <model> --verbose muestra el número de tokens del prompt después de una respuesta.

Presupuesta la ventana por idioma y por familia de modelos, porque los tokenizadores difieren entre familias de modelos.

¿Contexto largo o RAG para documentos?

Usa RAG cuando la respuesta está en unos pocos pasajes de una colección grande, y contexto largo cuando el modelo debe razonar sobre un documento coherente.

RAG (retrieval-augmented generation) recupera los fragmentos más relevantes, a menudo unos pocos miles de tokens en total, y mantiene el prompt corto. El contexto largo conserva las referencias cruzadas, como las cláusulas de un contrato o las cadenas de llamadas de una base de código, que la fragmentación puede partir.

Muchas configuraciones combinan ambos: recuperar secciones completas en lugar de fragmentos y colocarlas en una ventana de 32K a 128K. Consulta Mejores herramientas RAG locales para las opciones locales y RAG explicado para el método.

Errores comunes con LLM locales de contexto largo

  • Fiarse del contexto por defecto: Ollama usa 4K tokens por defecto por debajo de 24 GiB de VRAM, sea cual sea el soporte del modelo, así que un documento de 100 páginas se trunca antes de que el modelo lo lea. Define el contexto de forma explícita y confírmalo en la columna CONTEXT de ollama ps.
  • Presupuestar la memoria según el tamaño de descarga: la caché KV puede superar a los pesos. Llama 3.1 8B es una descarga de 4.9 GB, pero necesita unos 16 GiB de caché KV a 128K. Usa la fórmula o la tabla anterior antes de subir el contexto.
  • Suponer que todas las etiquetas tienen la ventana larga: en la biblioteca de Ollama qwen3:14b lista 40K mientras que qwen3:30b lista 256K. Lee la cifra de contexto en la página del modelo antes de planificar.
  • Tratar la ventana anunciada como la utilizable: RULER y NoLiMa encontraron caídas fuertes de precisión a 32K en muchos modelos que anuncian 128K o más. Prueba con tus propios documentos a la longitud que piensas usar.
  • Recurrir a 1M tokens por defecto: el tiempo de prellenado y la memoria crecen con el prompt, y Unsloth advierte de que 1M puede provocar cierres por falta de memoria en Nemotron 3 Nano. Usa 1M para tareas ocasionales y prefiere RAG o fragmentación para el trabajo diario.
  • Elegir q4_0 para la caché KV sin probar: Ollama documenta una pérdida de precisión de pequeña a media en q4_0 que puede notarse más con contextos mayores, y el ajuste se aplica a todos los modelos. Empieza con q8_0.

Preguntas frecuentes

¿Cuál es la ventana de contexto más larga que puede usar un LLM local en 2026?

Llama 4 Scout lista 10M tokens, pero su ficha publica benchmarks a 128K y la descarga de Ollama es de 67 GB. Entre los modelos que funcionan en un equipo de consumo, NVIDIA Nemotron 3 Nano 30B-A3B admite 1M tokens (256K es la configuración por defecto), y Qwen3.8 y Qwen3.5 admiten 256K de forma nativa y hasta aproximadamente 1M con YaRN. Que una ventana larga sea utilizable depende de la memoria y de la precisión con la que el modelo lee entradas largas.

¿Sigue siendo suficiente una ventana de contexto de 128K?

128K tokens son unas 100,000 palabras, suficientes para la mayoría de los documentos individuales. Un libro de 300 páginas suele tener entre 75,000 y 100,000 palabras, unos 100K a 135K tokens, así que normalmente supera una ventana de 128K o apenas cabe, sin espacio para preguntas y respuestas. Una ventana de 256K contiene el libro y la respuesta; más allá, usa RAG o fragmentación.

¿Cuánta memoria necesita un contexto de 1M tokens?

Depende de la arquitectura. Según las configuraciones publicadas, la caché KV en f16 a 1M tokens es de unos 32 GiB en Qwen3.5 9B, unos 64 GiB en Qwen3.8 27B y unos 6 GiB en Nemotron 3 Nano 30B-A3B, además de los pesos. Qwen indica que 1M tokens con Qwen3-30B-A3B-Instruct-2507 necesitan unos 240 GB de memoria de GPU. Una caché q8_0 reduce a la mitad los valores de KV, y el tiempo de leer un prompt de 1M tokens crece con su longitud, así que resérvalo para tareas ocasionales.

¿Por qué modelos con la misma ventana de contexto necesitan cantidades distintas de memoria?

La caché KV crece con capas de atención completa × cabezas KV × dimensión de cabeza × tokens. Llama 3.1 8B necesita 128 KiB por token, Gemma 4 26B-A4B unos 20 KiB porque solo 5 de sus 30 capas usan atención completa, y Nemotron 3 Nano unos 6 KiB porque solo 6 de sus 52 capas son de atención. Las capas de ventana deslizante, de atención lineal y Mamba mantienen un estado de tamaño fijo en lugar de crecer con la ventana.

¿Qué es la caché KV y cómo puedo reducirla?

La caché KV guarda las claves y valores de atención de cada token del contexto para que el modelo no los recalcule con cada token nuevo. Se reserva además de los pesos y crece con la longitud de contexto. Para reducirla, baja num_ctx, activa Flash Attention y define OLLAMA_KV_CACHE_TYPE como q8_0 (aproximadamente la mitad de la memoria de f16) o q4_0 (aproximadamente una cuarta parte, con más pérdida de precisión en contextos largos), o elige un modelo con una caché menor por token. En Ollama el tipo de caché es global y se aplica a todos los modelos.

¿Por qué mi modelo local olvida el principio de mi documento?

Lo más probable es que el contexto activo sea más pequeño que tu documento. Ollama usa por defecto 4K tokens en GPU con menos de 24 GiB de VRAM, 32K entre 24 y 48 GiB y 256K desde 48 GiB, sea cual sea el soporte del modelo, y la entrada que supera el contexto se trunca. Comprueba la columna CONTEXT de ollama ps y súbelo con OLLAMA_CONTEXT_LENGTH, /set parameter num_ctx, un Modelfile o la opción num_ctx de la API.

¿Cómo configuro un contexto de 128K en Ollama?

Crea un Modelfile con FROM qwen3.5:9b y PARAMETER num_ctx 131072, ejecuta ollama create qwen3.5-9b-128k -f Modelfile, luego ollama run qwen3.5-9b-128k y verifica con ollama ps. Como alternativa, inicia el servidor con OLLAMA_CONTEXT_LENGTH=131072 ollama serve. Antes comprueba que los pesos más la caché KV caben en memoria; en Qwen3.5 9B son unos 6.6 GB más 4 GiB.

¿Un contexto más largo hace más lento a un LLM local?

Sí. El modelo debe leer todo el prompt (prellenado) antes de escribir el primer token, así que el tiempo hasta el primer token crece con la longitud del prompt, y la atención sobre una caché mayor también reduce la velocidad de generación. Las capas de atención lineal y Mamba reducen el crecimiento, pero no lo eliminan. Mide en tu hardware con ollama run <model> --verbose, que muestra las velocidades de evaluación del prompt y de generación.

¿Qué es el problema «lost in the middle» y sigue vigente?

Liu et al. (2023) comprobaron que los modelos de lenguaje responden con más precisión cuando el texto relevante está al principio o al final de la entrada y con menos precisión cuando está en el medio. RULER (2024) y NoLiMa (2025) mostraron después que muchos modelos con ventanas de 32K a 128K pierden precisión mucho antes de su límite. Esos estudios probaron modelos anteriores, así que haz tu propia comprobación: esconde un dato al 10 %, 50 % y 90 % de un prompt largo y pregúntalo. Pon las instrucciones críticas al principio o al final, o recupera solo los pasajes relevantes.

¿Es mejor el contexto largo o RAG para responder preguntas sobre documentos?

RAG suele costar menos memoria y tiempo cuando la respuesta está en unos pocos pasajes de una colección grande, porque mantiene el prompt en unos pocos miles de tokens. El contexto largo es mejor cuando el modelo debe razonar sobre un documento coherente, como un contrato, una base de código o un capítulo de libro, donde la fragmentación partiría referencias cruzadas. Muchas configuraciones combinan ambos recuperando secciones completas en una ventana de 32K a 128K.

¿Puedo resumir un libro entero con un LLM local?

Un libro de 300 páginas son unos 100K a 135K tokens, así que cabe en una ventana de 256K (Qwen3.5, Qwen3.8, Gemma 4 desde 12B) y puede no caber en una de 128K al contar el resumen. Con un modelo de 128K o menos memoria, resume capítulo por capítulo y después resume los resúmenes. Define num_ctx de forma explícita para que todo el libro esté en el contexto activo.

¿Los documentos en otros idiomas consumen más ventana de contexto?

Pueden hacerlo. Petrov et al. (2023) comprobaron que el mismo texto puede necesitar hasta 15 veces más tokens en un idioma que en otro, según el tokenizador. Cuenta los tokens con tu modelo en lugar de usar la regla inglesa de 0.75 palabras por token: ollama run <model> --verbose muestra el número de tokens del prompt.

¿Qué modelos de contexto largo funcionan en un equipo de 16 GB?

Por aritmética de memoria, Qwen3.5 9B (descarga de 6.6 GB más unos 4 GiB de caché KV a 128K) y Gemma 4 12B (7.7 GB más unos 4.3 GiB en su ventana completa de 256K) caben en 16 GB con unos GB de margen. Son cálculos a partir de configuraciones publicadas, no ejecuciones medidas; confirma con ollama ps.

Fuentes

¿Necesitas dimensionar la memoria para un contexto largo? Empieza por la guía de hardware.

Guía de hardware para LLM locales →

Nota sobre hechos de terceros

Este artículo hace referencia a modelos de IA, benchmarks, precios y licencias de terceros. El panorama de la IA cambia rápidamente. Las puntuaciones de benchmark, los términos de licencia, los nombres de modelos y los precios de API pueden cambiar entre el momento en que se escribió y cuando usted lo lee. Antes de tomar decisiones de despliegue o cumplimiento basadas en este artículo, verifique las cifras actuales en la fuente oficial de cada proveedor: tarjetas de modelos de Hugging Face para licencias y benchmarks, sitios web de proveedores para precios de API y EUR-Lex para el texto actualizado del RGPD y la Ley de IA de la UE.

Usa PromptQuorum con un LLM local, tus propias claves API o ambos — tú eliges el backend.

Descargar la beta de PromptQuorum →

← Back to Local LLMs

MCP