¿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-A3B | 1M (por defecto 256K) | — | ollama run nemotron-3-nano:30b |
| Qwen3.8 27B | 256K | Hasta 1M (YaRN) | ollama run qwen3.8:27b |
| Qwen3.5 9B / 27B | 256K | Hasta 1.01M (YaRN) | ollama run qwen3.5:9b |
| Qwen3 30B-A3B-2507 | 256K | 1M (DCA, ~240 GB GPU) | ollama run qwen3:30b |
| Gemma 4 12B / 26B / 31B | 256K | — | ollama run gemma4:26b |
| Gemma 4 E2B / E4B | 128K | — | ollama run gemma4:e4b |
| Llama 4 Scout 109B | 10M listados | Benchmarks a 128K | ollama run llama4:16x17b |
| Mistral Small 3.2 24B | 128K | — | ollama run mistral-small3.2 |
| gpt-oss 20B | 128K | — | ollama run gpt-oss:20b |
| Llama 3.1 8B | 128K | — | ollama run llama3.1:8b |
| Qwen3 8B / 14B | 40K | — | ollama run qwen3:14b |
¿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 8B | 4.9 GB | 4 GiB | 16 GiB | 16 GiB (128K) |
| Mistral Small 3.2 24B | 15 GB | 5 GiB | 20 GiB | 20 GiB (128K) |
| gpt-oss 20B | 14 GB | 0.8 GiB | 3 GiB | 3 GiB (128K) |
| Qwen3.5 4B | 3.3 GB | 1 GiB | 4 GiB | 8 GiB (256K) |
| Qwen3.5 9B | 6.6 GB | 1 GiB | 4 GiB | 8 GiB (256K) |
| Gemma 4 12B | 7.7 GB | 0.8 GiB | 2.3 GiB | 4.3 GiB (256K) |
| Gemma 4 26B-A4B | 16 GB | 0.8 GiB | 2.7 GiB | 5.2 GiB (256K) |
| Gemma 4 31B | 19 GB | 3.3 GiB | 10.8 GiB | 20.8 GiB (256K) |
| Qwen3.8 27B | 18 GB | 2 GiB | 8 GiB | 16 GiB (256K) |
| Qwen3.5 35B-A3B | 22 GB | 0.6 GiB | 2.5 GiB | 5 GiB (256K) |
| Qwen3 30B-A3B-2507 | 19 GB | 3 GiB | 12 GiB | 24 GiB (256K) |
| Nemotron 3 Nano 30B-A3B | 18 GB | 0.2 GiB | 0.8 GiB | 6 GiB (1M) |
¿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.
¿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.
# 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¿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
- Ollama. (2026). "Context length" documentation. docs.ollama.com -- contexto por defecto según el nivel de VRAM, OLLAMA_CONTEXT_LENGTH, recomendación de 64,000 tokens para agentes.
- Ollama. (2026). "FAQ". docs.ollama.com -- /set parameter num_ctx, OLLAMA_FLASH_ATTENTION, OLLAMA_KV_CACHE_TYPE (f16, q8_0, q4_0).
- Ollama. (2026). "qwen3.8" library page. ollama.com -- 27B, 18 GB, contexto de 256K.
- Ollama. (2026). "qwen3.5" library page. ollama.com -- etiquetas de 0.8B a 122B, contexto de 256K.
- Ollama. (2026). "qwen3" library page. ollama.com -- 40K para 8B/14B/32B, 256K para 4B/30B.
- Ollama. (2026). "gemma4" library page. ollama.com -- E2B/E4B 128K, 12B/26B/31B 256K.
- Ollama. (2026). "nemotron-3-nano" library page. ollama.com -- la etiqueta 30B lista contexto de 1M, 18 GB.
- Ollama. (2026). "llama4" library page. ollama.com -- Scout 67 GB y 10M, Maverick 245 GB y 1M.
- Ollama. (2026). "mistral-small3.2", "gpt-oss" y "llama3.1" library pages. ollama.com -- ventanas de 128K, descargas de 15 GB, 14 GB y 4.9 GB.
- Qwen Team. (2026). "Qwen3.8-27B" model card. huggingface.co -- 262,144 nativos, hasta 1,000,000 con YaRN, Apache-2.0.
- Qwen Team. (2026). "Qwen3.5-9B" model card. huggingface.co -- 262,144 nativos, hasta 1,010,000 con YaRN; diseño híbrido Gated DeltaNet.
- Qwen Team. (2025). "Qwen3-30B-A3B-Instruct-2507" model card. huggingface.co -- 262,144 nativos, 1M con Dual Chunk Attention, unos 240 GB de memoria de GPU.
- Google. (2026). "Gemma 4 31B" model card. huggingface.co -- 128K para E2B/E4B, 256K para los tamaños mayores.
- NVIDIA. (2025). "NVIDIA-Nemotron-3-Nano-30B-A3B-BF16" model card. huggingface.co -- 23 capas Mamba-2 y MoE más 6 capas de atención, 1M admitido, 256K por defecto.
- Meta. (2025). "Llama-4-Scout-17B-16E-Instruct" model card. huggingface.co -- 109B en total, 10M listados, benchmarks de contexto largo a 128K.
- Unsloth. (2026). "NVIDIA Nemotron 3 Nano -- How To Run Guide". unsloth.ai -- el contexto de 1M puede quedarse sin memoria, 262,144 por defecto.
- Liu et al. (2023). "Lost in the Middle: How Language Models Use Long Contexts". arxiv.org -- la precisión es mayor al principio y al final de la entrada.
- Hsieh et al. (2024). "RULER: What's the Real Context Size of Your Long-Context Language Models?". arxiv.org -- solo la mitad aproximadamente de 17 modelos que anuncian 32K+ sigue siendo satisfactoria a 32K.
- Modarressi et al. (2025). "NoLiMa: Long-Context Evaluation Beyond Literal Matching". arxiv.org -- 11 de 13 modelos caen por debajo del 50 % de su puntuación con contexto corto a 32K.
- Petrov et al. (2023). "Language Model Tokenizers Introduce Unfairness Between Languages". arxiv.org -- hasta 15 veces más tokens para el mismo texto.
- llama.cpp. "llama-server" README. github.com -- --ctx-size, --flash-attn, --cache-type-k, --cache-type-v.
- LM Studio. "Per-model default parameters". lmstudio.ai -- tamaño de contexto y Flash Attention por modelo.
- Los tamaños de caché KV de esta guía se calculan a partir del config.json de cada repositorio de modelo en Hugging Face (capas, cabezas KV, dimensión de cabeza, tipos de capa de atención) y no se han medido.
