LLM on kenji.blog

Guía de uso de llama.cpp e introducción a la personalización en C++

Fri, 11 Sep 2026 11:00:00 +0900

En los últimos años, la evolución de los Grandes Modelos de Lenguaje (LLM) ha sido asombrosa, y su ámbito de aplicación se expande día a día. Sin embargo, para ejecutar modelos con miles o decenas de miles de millones de parámetros en un entorno local, normalmente se requiere una GPU de gama alta con una enorme cantidad de VRAM. Quien ha derribado este “muro de hardware” y ha hecho posible la inferencia práctica de LLMs en PCs y Macs comunes, e incluso en dispositivos como Raspberry Pi, es llama.cpp.

En este artículo, no nos limitaremos a explicar cómo usar la herramienta de línea de comandos, sino que profundizaremos detalladamente para ingenieros en la arquitectura de su tecnología base ggml, el trasfondo matemático de los Transformers y la cuantización, así como la forma de integrar y personalizar LLMs en aplicaciones propias utilizando la API de C++.

1. Visión general de llama.cpp y ggml

llama.cpp es un motor de inferencia de LLM ligero escrito en C/C++ desarrollado por Georgi Gerganov. Originalmente nació con el objetivo de ejecutar rápidamente el modelo LLaMA de Meta en Apple Silicon (M1/M2 Mac), pero en la actualidad soporta diversas arquitecturas y modelos.

Su mayor característica es que es una implementación pura en C/C++ sin dependencias externas. No requiere ecosistemas gigantescos como Python o PyTorch, y dado que se puede compilar como un único archivo ejecutable, su despliegue es sumamente sencillo.

El corazón de este llama.cpp es la biblioteca de operaciones con tensores ggml. ggml está diseñada desde cero para optimizar al máximo las operaciones matriciales de aprendizaje automático en CPU (y algunas GPU).

1.1 ¿Por qué llama.cpp es rápido?

Uso de mapeo de memoria (mmap): Al cargar los pesos del modelo en memoria, se utiliza la función mmap del sistema operativo, evitando cargar todo en la RAM y logrando un inicio rápido y un uso eficiente de la memoria.
Optimización exhaustiva de instrucciones SIMD: Se aprovechan los conjuntos de instrucciones específicos de la CPU como AVX2, AVX-512, ARM NEON y Apple AMX, acelerando exponencialmente la multiplicación de matrices.
Cuantización (Quantization): Comprime los pesos de números de punto flotante de 16 bits (FP16) a enteros de 4, 5 u 8 bits, eliminando los cuellos de botella del ancho de banda de la memoria (se explicará en detalle más adelante).

2. Trasfondo matemático: Transformer y Cuantización (Quantization)

Para comprender profundamente llama.cpp, es necesario conocer las fórmulas matemáticas que calcula y cómo aproxima dichos cálculos.

2.1 Proceso de inferencia del Transformer

Modelos como LLaMA adoptan una arquitectura de decodificador Transformer de tipo autorregresivo (Auto-regressive). El núcleo de la generación de texto es el mecanismo de Self-Attention.

Para una matriz de estado oculto de entrada $X \in \mathbb{R}^{N \times d}$, la consulta $Q$ (Query), la clave $K$ (Key) y el valor $V$ (Value) se calculan mediante el producto con matrices de pesos.

$$ Q = X W_Q, \quad K = X W_K, \quad V = X W_V $$

Aquí, la salida de la Attention se define de la siguiente manera:

$$ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V $$

En el bucle de inferencia de llama.cpp, el cuello de botella es el producto de estas enormes matrices $W_Q, W_K, W_V$ o la matriz de pesos de la red prealimentada (FFN) con el vector $X$ (en la fase de generación, como se procesa token por token, $N=1$), es decir, GEMV (General Matrix-Vector Multiplication).

2.2 Fundamentos matemáticos de la Cuantización

En la inferencia donde el ancho de banda de acceso a memoria se convierte en el cuello de botella, la cuantización, que representa los parámetros de peso con un número reducido de bits, es indispensable. Explicaremos el principio básico de la cuantización por bloques (por ejemplo, Q4_K o Q4_0) ampliamente utilizada en llama.cpp.

Por ejemplo, consideremos un bloque $w = [w_1, w_2, \dots, w_B]$ de longitud $B$ (generalmente 32 o 64) que es parte de la matriz de pesos FP16 $W$. Este bloque se aproxima a un entero de 4 bits $q_i \in [-8, 7]$ y un único factor de escala $\Delta$ (FP16 o FP32).

$$ w_i \approx \Delta \times q_i $$

$\Delta$ se determina en base al valor absoluto máximo dentro del bloque.

$$ \Delta = \frac{\max_i |w_i|}{7} $$

Al calcular el producto punto $y = w \cdot x$ utilizando los pesos cuantizados, si cuantizamos el vector de entrada $x$ de la misma manera como $x_i \approx \Delta_x \times q_{x, i}$, tenemos:

$$ y = \sum_{i=1}^{B} w_i x_i \approx \Delta \Delta_x \sum_{i=1}^{B} q_i q_{x, i} $$

Esta parte de $\sum q_i q_{x, i}$ se convierte en aritmética puramente entera, y se puede calcular en paralelo a una velocidad altísima utilizando instrucciones SIMD. Este es el truco matemático por el cual llama.cpp logra velocidades sorprendentes en CPU.

3. Arquitectura y flujo de inferencia

Para comprender el funcionamiento interno de llama.cpp, el siguiente diagrama de Mermaid muestra la arquitectura de todo el sistema y el flujo de datos.

graph TD A["Entrada del usuario (String)"] --> B["Tokenizer de llama.cpp"] B --> C["IDs de tokens (Array de int32)"] C --> D["Buffer de contexto (KV Cache)"] D --> E["Grafo de computación de ggml"] E --> F["Capas del Transformer"] subgraph "Motor ggml" F --> G["Self-Attention (RoPE)"] G --> H["Red Neuronal Prealimentada (FFN)"] H --> F end F --> I["Logits (Tamaño del Vocabulario)"] I --> J["Muestreador (Temperature, Top-K, Top-P)"] J --> K["ID del token seleccionado"] K --> L["Detokenizer de llama.cpp"] L --> M["Cadena de salida"] K -. "Bucle autorregresivo" .-> D

La generación de texto es un bucle autorregresivo donde, cada vez que se emite un token, este se añade a la KV Cache como la siguiente entrada y pasa nuevamente por el grafo de computación.

4. Configuración del entorno y método de compilación

Antes de integrar llama.cpp en un proyecto C++, primero intentemos compilar el código fuente.

4.1 Clonar el repositorio

1
2


git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp

4.2 Compilación usando CMake

Para integrarlo como un proyecto C++ en otras aplicaciones, usar CMake es lo más estándar. Al habilitar los aceleradores (backends) específicos de la plataforma, se puede acelerar el cálculo.

Solo CPU (Compilación básica):

1
2
3


mkdir build && cd build
cmake ..
cmake --build . --config Release -j 8

Al usar una GPU de NVIDIA (CUDA):

1
2
3


mkdir build && cd build
cmake .. -DGGML_CUDA=ON
cmake --build . --config Release -j 8

Al usar Apple Silicon (Metal):

1
2
3


mkdir build && cd build
cmake .. -DGGML_METAL=ON
cmake --build . --config Release -j 8

Si la compilación es exitosa, se generarán archivos ejecutables como llama-cli en el directorio build/bin/ y la biblioteca llama (así como la biblioteca ggml) para enlazar a través de la API de C++ descrita a continuación.

5. Introducción a la personalización en C++: Uso de la API de llama.cpp

A partir de aquí, explicaremos el tema principal: el control de llama.cpp desde código en C++. Para integrar un LLM en tu propia aplicación (por ejemplo, motores de juegos, aplicaciones de escritorio, sistemas integrados, etc.), más allá de usar la herramienta de línea de comandos, es necesario llamar directamente a la API de C++.

llama.cpp proporciona principalmente una interfaz en lenguaje C a través del archivo de cabecera llama.h. Esta interfaz también se utiliza cuando se llama desde C++.

5.1 Inclusiones y configuraciones mínimas necesarias

Al usar llama.cpp en tu propio proyecto, incluye lo siguiente:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include "llama.h"
#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>

// Macro para el manejo de errores
#define LLAMA_ASSERT(x) \
 do { \
 if (!(x)) { \
 std::cerr << "Assertion failed: " << #x << std::endl; \
 std::terminate(); \
 } \
 } while (0)

5.2 Carga del modelo e inicialización del contexto

Primero, cargamos un archivo de modelo en formato .gguf y reservamos el contexto (espacio de memoria y KV cache) para la inferencia.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


int main(int argc, char ** argv) {
 if (argc < 2) {
 std::cerr << "Usage: " << argv[0] << " <model.gguf>" << std::endl;
 return 1;
 }
 std::string model_path = argv[1];

 // 1. Inicialización del backend (Configuración del entorno para CPU/GPU, etc.)
 llama_backend_init();

 // 2. Obtener la configuración por defecto de los parámetros del modelo
 llama_model_params model_params = llama_model_default_params();
 model_params.n_gpu_layers = 35; // Número de capas a descargar en la GPU

 // 3. Carga del modelo
 llama_model * model = llama_load_model_from_file(model_path.c_str(), model_params);
 if (model == nullptr) {
 std::cerr << "Failed to load model" << std::endl;
 return 1;
 }

 // 4. Configuración de los parámetros del contexto
 llama_context_params ctx_params = llama_context_default_params();
 ctx_params.n_ctx = 2048; // Tamaño máximo de contexto (número de tokens)
 ctx_params.n_threads = 8; // Número de hilos de CPU utilizados para la inferencia

 // 5. Creación del contexto
 llama_context * ctx = llama_new_context_with_model(model, ctx_params);
 if (ctx == nullptr) {
 std::cerr << "Failed to create context" << std::endl;
 llama_free_model(model);
 return 1;
 }

 std::cout << "Model and context loaded successfully!" << std::endl;
 // ... Procesamiento subsiguiente

5.3 Tokenización de la solicitud (Tokenization)

Los LLMs no entienden el texto directamente, sino que lo procesan como una secuencia de IDs enteros (tokens). Es necesario convertir la cadena de entrada en tokens.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


 std::string prompt = "Q: ¿Cuál es la capital de Japón?\nA:";
 std::vector<llama_token> tokens_list;
 tokens_list.resize(prompt.length() + 4); // Tamaño del buffer con un margen extra

 // Si añadir o no tokens especiales (BOS: Begin of Sequence, etc.) al principio
 bool add_special = true;
 // Convertir la cadena en un array de IDs de tokens
 int n_tokens = llama_tokenize(
 model,
 prompt.c_str(),
 prompt.length(),
 tokens_list.data(),
 tokens_list.size(),
 add_special,
 false // parse_special
 );

 if (n_tokens < 0) {
 // Lógica necesaria para reasignar y reintentar si el buffer es insuficiente (omitido por simplicidad)
 std::cerr << "Failed to tokenize prompt" << std::endl;
 return 1;
 }
 tokens_list.resize(n_tokens);

5.4 Bucle de inferencia y muestreo

Construiremos un bucle que introduce tokens en el modelo, obtiene la distribución de probabilidades (Logits) del siguiente token, realiza el muestreo y determina el siguiente token.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


 // Número máximo de tokens a generar
 const int max_gen_tokens = 100;

 // Inicializar la estructura para la evaluación por lotes (batch)
 llama_batch batch = llama_batch_init(512, 0, 1);

 // Añadir los tokens del prompt al batch
 for (size_t i = 0; i < tokens_list.size(); i++) {
 llama_batch_add(batch, tokens_list[i], i, { 0 }, false);
 }
 // Configurar para emitir los logits (resultados de la predicción) solo en el último token del prompt
 batch.logits[batch.n_tokens - 1] = true;

 // Primera evaluación (alimentar el modelo con el prompt)
 if (llama_decode(ctx, batch) != 0) {
 std::cerr << "llama_decode() failed" << std::endl;
 return 1;
 }

 int n_cur = batch.n_tokens; // Longitud de contexto actual
 int n_decode = 0;

 std::cout << "\nOutput: ";

 // Inicialización del contexto del muestreador (configuración de Temperature, Top-K, Top-P, etc.)
 llama_sampler * smpl = llama_sampler_chain_init(llama_sampler_chain_default_params());
 llama_sampler_chain_add_top_k(smpl, 40);
 llama_sampler_chain_add_top_p(smpl, 0.9f, 1);
 llama_sampler_chain_add_temp(smpl, 0.7f);
 llama_sampler_chain_add_dist(smpl, 1234); // Valor semilla (seed)

 while (n_decode < max_gen_tokens) {
 // 1. Muestreo: Predecir el siguiente token basado en el contexto actual
 llama_token new_token_id = llama_sampler_sample(smpl, ctx, -1);

 // 2. Terminar el bucle si el token es EOS (End of Sequence)
 if (llama_token_is_eog(model, new_token_id)) {
 break;
 }

 // 3. Decodificar el token a una cadena (texto) para mostrarlo
 char buf[128];
 int n_chars = llama_token_to_piece(model, new_token_id, buf, sizeof(buf), 0, false);
 if (n_chars > 0) {
 std::cout << std::string(buf, n_chars) << std::flush;
 }

 // 4. Preparar el token recién generado como el siguiente lote (batch)
 llama_batch_clear(batch);
 llama_batch_add(batch, new_token_id, n_cur, { 0 }, true);

 // 5. Evaluación del modelo (Actualizar la KV cache y predecir lo siguiente)
 if (llama_decode(ctx, batch) != 0) {
 std::cerr << "Failed to evaluate" << std::endl;
 break;
 }

 n_cur += 1;
 n_decode += 1;
 }

 std::cout << std::endl;

 // Limpieza (Cleanup)
 llama_sampler_free(smpl);
 llama_batch_free(batch);
 llama_free(ctx);
 llama_free_model(model);
 llama_backend_free();

 return 0;
}

Este código implementa un bucle de inferencia personalizado utilizando la API básica de llama.cpp. Utiliza la estructura llama_batch para gestionar el grupo de tokens y llama_decode para ejecutar el pase hacia adelante (forward pass) de la red neuronal.

6. Caso de personalización avanzada: Manipulación de Logits y control de penalizaciones en C++

Para no limitarse a la simple generación de texto y, en su lugar, forzar un formato de salida específico (por ejemplo, solo JSON) o evitar la aparición de ciertas palabras prohibidas, manipulamos directamente los Logits en C++ antes del muestreo.

Se puede obtener el array de puntuaciones en bruto (los valores antes de convertirse en probabilidades) justo antes de que el modelo emita cada token.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// Obtener el array de logits en bruto después de la inferencia y antes de realizar el muestreo
float * logits = llama_get_logits_ith(ctx, batch.n_tokens - 1);
int n_vocab = llama_n_vocab(model);

// Lista de IDs de tokens prohibidos (por ejemplo, 1234, 5678)
std::vector<llama_token> forbidden_tokens = { 1234, 5678 };

// Establecer la probabilidad de aparición de los tokens prohibidos a 0 (Logit a menos infinito)
for (llama_token bad_tok : forbidden_tokens) {
 logits[bad_tok] = -INFINITY;
}

De esta manera, al interactuar directamente con la API de C++, se hace posible una “intervención a nivel de micro o milisegundos en cada ciclo de inferencia”, lo cual sería difícil de lograr o tendría una gran sobrecarga (overhead) si se hiciera a través de LangChain o Python.

7. Los secretos del ajuste de rendimiento (Performance Tuning)

Después de completar la implementación en C++, presentamos algunos puntos de control para llevar la velocidad al límite en un entorno de producción.

Optimización del procesamiento por lotes (Batching): Cuando se procesan simultáneamente peticiones de múltiples usuarios, se puede incluir múltiples secuencias en el llama_batch y llamar a llama_decode a la vez (Continuous Batching). Esto permite compartir el acceso a la memoria y aumentar dramáticamente el rendimiento (throughput).
Habilitación de Flash Attention: Configurando ctx_params.flash_attn = true; en los parámetros de contexto, se puede reducir el uso de memoria a la vez que se acelera el cálculo de Attention. Es una configuración indispensable cuando se manejan contextos largos (decenas de miles de tokens).
Soporte NUMA: En entornos de servidor de múltiples sockets, realizar una configuración NUMA adecuada antes de llama_backend_init() permite reducir la latencia de acceso a la memoria.

8. Conclusión

En este artículo, hemos detallado desde el trasfondo matemático de llama.cpp y la explicación de su arquitectura, hasta cómo construir un motor de inferencia personalizado aprovechando la API de C++.

El ecosistema de Python es muy útil para prototipos, pero en entornos de producción que requieren despliegue en dispositivos edge, integración en juegos y procesamiento en tiempo real, el control directo basado en C/C++ de llama.cpp muestra un poder abrumador.

Te animamos a que escribas código C++ por ti mismo y experimentes la diversión de controlar un LLM libremente en tu entorno local.

Enlaces de referencia

Repositorio Oficial de llama.cpp

ggml - Tensor Library

Attention Is All You Need (Vaswani et al., 2017)

【Último en 2026】Guía completa para ejecutar LLM locales en un entorno Windows

Fri, 11 Sep 2026 10:00:00 +0900

1. Introducción: ¿Por qué LLM locales en Windows ahora?

En 2026, la evolución de la IA generativa y los Grandes Modelos de Lenguaje (LLM) muestra un cambio de paradigma importante: desde servicios API gigantes en la nube hasta “LLM locales” que se ejecutan en PCs personales y entornos on-premise. Aunque las IA en la nube como GPT-5 de OpenAI o Claude 3.5 de Anthropic son extremadamente potentes, no todas las empresas o individuos pueden enviar todos sus datos a la nube. Desde el punto de vista de la privacidad, seguridad, latencia y los costes sostenibles a largo plazo, la demanda de LLM locales ha crecido explosivamente como nunca antes.

Especialmente en el entorno Windows, la evolución del ecosistema de LLM locales es notable. Hasta hace unos años, el sentido común dictaba que “el desarrollo y la ejecución de IA significaba Linux”, pero en 2026 Windows se ha transformado en una plataforma de IA extremadamente potente y accesible.

Este artículo, basado en las últimas tendencias tecnológicas de 2026, proporciona una guía completa para construir, operar y optimizar un LLM local en un entorno Windows. Cubriremos exhaustivamente desde una configuración simple con Ollama para principiantes, hasta una optimización extrema usando llama.cpp para usuarios avanzados, además de profundizar en el enfoque matemático del cálculo de VRAM, una comprensión profunda de la arquitectura y el fine-tuning local.

1.1 Tendencias tecnológicas que rodean a los LLM locales en 2026

Las principales tendencias que conforman el ecosistema actual de los LLM locales son las siguientes:

Adopción total del formato GGUF: El GGUF (GPT-Generated Unified Format), que integra metadatos y tensores en un solo archivo, se ha convertido en el estándar de facto. Esto permite que con solo descargar un archivo desde Hugging Face, se pueda ejecutar en cualquier entorno.
Democratización de la arquitectura MoE (Mixture of Experts): Se han lanzado numerosos modelos MoE de pequeña escala pero de alto rendimiento, que al activar solo ciertos expertos durante la inferencia, logran un rendimiento comparable al de modelos gigantes mientras mantienen bajo el uso de computación en PCs de consumo.
Abstracción y optimización avanzadas de los motores de inferencia: Herramientas como Ollama, LM Studio y AnythingLLM se han perfeccionado, eliminando la necesidad de que los usuarios se preocupen por dependencias complejas como la instalación de controladores CUDA. Además, el soporte nativo de FlashAttention 3 en Windows ha mejorado drásticamente la velocidad de inferencia.
Utilización de NPU y el auge de las PC Windows Copilot+: Incluso en laptops sin GPU, la tecnología para ejecutar pequeños LLM (SLM: Small Language Models) con bajo consumo energético utilizando la NPU (Neural Processing Unit) integrada ha alcanzado una etapa práctica.

2. Requisitos de hardware y preparación del SO

Para ejecutar un LLM local a una velocidad práctica (más de 15-30 tokens por segundo), la selección del hardware es lo más importante.

2.1 Configuración de hardware recomendada

Con la evolución de los PC con IA, las especificaciones requeridas también están cambiando.

SO: Windows 11 Pro (24H2 o posterior). Indispensable para utilizar las funcionalidades completas de WSL2, la gestión avanzada de memoria y las últimas API de DirectML.
CPU: Intel Core Ultra serie 200 o superior, o AMD Ryzen serie 9000 o superior. Si se utiliza la inferencia por CPU de forma combinada, es esencial una comunicación de memoria de gran ancho de banda.
RAM: Mínimo 32 GB, recomendado 64 GB o más. El ancho de banda de la memoria principal (MB/s) se convierte en el cuello de botella decisivo durante la inferencia por CPU o la descarga (offloading). Una memoria rápida como DDR5-6000 o superior es ideal.
GPU: NVIDIA RTX serie 4000/5000. Lo más importante en los LLM locales no es el rendimiento de cálculo, sino la “capacidad de VRAM”.
- Entrada: RTX 4060 Ti (versión de 16 GB) - La mejor relación calidad-precio. Ideal para modelos de clase 8B a 14B.
- Gama media: RTX 4070 Ti SUPER (16 GB) / RTX 4080 SUPER (16 GB)
- Gama alta: RTX 4090 (24 GB) / RTX 5090 (32 GB) - Necesaria para ejecutar modelos cuantizados de clase 30B a 70B.
Almacenamiento: NVMe SSD PCIe Gen4 o Gen5. Reduce drásticamente el tiempo de carga de modelos de decenas de GB.

2.2 Configuración de WSL2 (Windows Subsystem for Linux 2)

Aunque muchas herramientas GUI funcionan de forma nativa en Windows, WSL2 es muy útil para el desarrollo con Python, la compilación de las últimas herramientas y el fine-tuning LoRA que veremos más adelante. En los entornos modernos de Windows 11, simplemente instalando el controlador NVIDIA en el host, la GPU (CUDA) se puede utilizar de forma transparente desde WSL2.

Abre PowerShell con privilegios de administrador y ejecuta lo siguiente:

1
2
3
4
5


# Instalación de WSL2 y el último Ubuntu
wsl --install -d Ubuntu-24.04

# Actualización del kernel
wsl --update

Después de la instalación, ejecuta nvidia-smi dentro de la terminal de WSL2. Si la GPU se reconoce correctamente, ha sido un éxito.

3. Arquitectura del LLM local y mecanismo de inferencia

Comprender cómo el modelo genera texto en un entorno local y su estructura interna es extremadamente útil para la resolución de problemas y la optimización.

El siguiente diagrama Mermaid muestra la ruta de inferencia típica de un LLM local.

graph TD User["Entrada del usuario (Prompt)"] --> Tokenizer["Tokenizador (Tokenizer)"] Tokenizer --> Embedding["Capa de incrustación (Embedding)"] subgraph "Bloque Transformer (x Capas)" Embedding --> Attn["Auto-atención (Self-Attention)"] Attn --> KVCache["Caché KV (Retención Key/Value)"] Attn --> FFN["Red feed-forward (FFN)"] end FFN --> Logits["Cálculo de logits (Logits)"] Logits --> Sampler["Muestreador (Temperature, Top-K, Top-P)"] Sampler --> OutputToken["Token de salida"] OutputToken --> |"Generación autorregresiva"| Tokenizer OutputToken --> Decoder["Detokenizador (Detokenizer)"] Decoder --> FinalOutput["Texto de salida final"]

3.1 Dos fases: Prefill y Decode

La generación de texto por parte de un LLM se divide en dos fases con diferentes características computacionales:

Fase de Prefill (Procesamiento del prompt): Fase en la que todo el prompt introducido se procesa y comprende a la vez. Dado que es posible el cálculo paralelo, la capacidad de cálculo de la GPU (FLOPS) está directamente relacionada con la velocidad. Si el prompt es largo, esta fase puede tardar varios segundos.
Fase de Decode (Generación de tokens): Fase en la que se predice un token a la vez y se pasa a la siguiente entrada (autorregresiva). Dado que el cálculo paralelo está limitado en esta fase, el ancho de banda de la VRAM (Memory Bandwidth) de la GPU se convierte en un cuello de botella decisivo.

4. Cálculo del consumo de VRAM y comprensión matemática del tamaño del modelo

Para determinar correctamente “qué modelos pueden ejecutarse en mi PC”, es necesario comprender la fórmula para calcular la VRAM. Cuando ocurre un fallback hacia la memoria del sistema (RAM) debido a la falta de VRAM, la velocidad de inferencia se ralentiza de 10 a 100 veces.

4.1 VRAM base según el tamaño de los parámetros

Esta es la cantidad de memoria requerida para cargar los pesos (weights) del modelo en la VRAM. Se calcula usando el tamaño del modelo $P$ (número de parámetros, unidad: 1000 millones = 1B) y el número de bytes por parámetro $B$.

$$ V_{base} = P \times B \quad \text{(GB)} $$

Por ejemplo, al cargar un modelo de parámetros 8B (8 mil millones) en FP16 (punto flotante de media precisión, 16 bits = 2 bytes):

$$ V_{base} = 8 \times 2 = 16 \text{ GB} $$

En otras palabras, incluso con una GPU de 16 GB de VRAM, se llega casi al límite solo con cargar el modelo.

4.2 La magia de la cuantización (Quantization)

Aquí es donde entra en juego la “cuantización”. Al reducir la precisión de los parámetros, el tamaño del modelo se reduce drásticamente. En el caso más común de la cuantización de 4 bits (ej: Q4_K_M), el promedio es de aproximadamente 0.55 bytes por parámetro.

$$ V_{base\_4bit} = 8 \times 0.55 = 4.4 \text{ GB} $$

Gracias a esto, si se tienen 16 GB de VRAM, se puede ejecutar un modelo 8B con mucho margen.

4.3 Cálculo de la caché KV (Versión compatible con GQA)

Durante la inferencia, la “caché KV”, que retiene el contexto pasado, consume VRAM. En los modelos más recientes como Llama 3, se adopta GQA (Grouped Query Attention) para ahorrar memoria.

El consumo de la caché KV $V_{kv}$ (en gigabytes) se expresa mediante la siguiente fórmula matemática:

$$ V_{kv} = 2 \times b \times s \times l \times \left( \frac{h_{kv}}{h_q} \right) \times h_q \times d \times B_{kv} \div 10^9 $$

Simplificando, se puede calcular fácilmente usando el número de cabezales (heads) de Key y Value $h_{kv}$:

$$ V_{kv} = 2 \times b \times s \times l \times h_{kv} \times d \times B_{kv} \div 10^9 $$

Donde:

$b$: Tamaño del lote (normalmente 1 para uso personal y local)
$s$: Longitud de la secuencia (longitud del contexto, ej: 8192)
$l$: Número de capas (ej: 32)
$h_{kv}$: Número de cabezales KV (ej: 8)
$d$: Número de dimensiones por cabezal (ej: 128)
$B_{kv}$: Número de bytes de la caché KV (2 para FP16)

Ejemplo de cálculo (Llama 3 8B, contexto 8192, caché FP16): $V_{kv} = 2 \times 1 \times 8192 \times 32 \times 8 \times 128 \times 2 \div 10^9 \approx 1.07 \text{ GB}$

Tenga en cuenta que cuanto mayor sea la longitud del contexto $s$, la VRAM requerida aumentará de forma lineal.

5. Práctica 1: Configuración más rápida y corta usando Ollama

Una vez entendida la teoría, ejecutemos un LLM en el entorno Windows. En 2026, la herramienta más amigable para el usuario es “Ollama”. Proporciona una CLI intuitiva tipo Docker.

5.1 Instalación y ejecución

Descarga el instalador para Windows desde el sitio web oficial de Ollama y ejecútalo.
Abre PowerShell e introduce el siguiente comando. Aquí usaremos llama3:8b, que soporta japonés.

1

ollama run llama3:8b

En la primera ejecución, se descargará el modelo. Una vez finalizado, podrás interactuar directamente en la terminal.

5.2 Creación de una IA personalizada mediante Modelfile

Puedes crear fácilmente una IA con una personalidad específica. Crea un Modelfile en cualquier ubicación.

1
2
3
4
5
6
7
8
9


FROM llama3:8b

SYSTEM """
Eres un ingeniero de software senior muy talentoso.
Al responder a las preguntas de los usuarios, debes incluir siempre ejemplos de código y responder de forma lógica y concisa.
"""

PARAMETER temperature 0.3
PARAMETER num_ctx 8192

Ejecuta el siguiente comando para compilar y ejecutar tu propio modelo.

1
2


ollama create SeniorDev -f ./Modelfile
ollama run SeniorDev

5.3 Uso desde aplicaciones externas (Editores de IA)

Ollama expone un punto de conexión de la API compatible con OpenAI en http://localhost:11434. Simplemente configurando esta URL en los ajustes de backend de extensiones de VS Code como Cursor o Continue.dev y especificando un modelo como SeniorDev, obtendrás un potente asistente de programación local y gratuito.

6. Práctica 2: Ajuste de rendimiento extremo con llama.cpp

Si quieres probar opciones como una gestión detallada de la memoria o los últimos formatos (EXL2, cuantización IQ, etc.) lo antes posible, interactúa directamente con el motor central, llama.cpp.

6.1 Pasos para compilar llama.cpp

En un entorno Windows, lo mejor es compilar desde el código fuente utilizando CUDA Toolkit y CMake.

1
2
3
4
5
6
7
8


git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
mkdir build
cd build

# Configurar para CUDA y compilar
cmake .. -DLLAMA_CUBLAS=ON -DBUILD_SHARED_LIBS=OFF
cmake --build . --config Release -j 16

6.2 Inicio avanzado en modo servidor

Utiliza el ejecutable llama-server.exe compilado para alojar el modelo.

1
2
3
4
5
6
7


.\bin\Release\llama-server.exe `
 --model "C:\models\Llama-3-8B-Instruct.Q4_K_M.gguf" `
 --ctx-size 8192 `
 --n-gpu-layers 99 `
 --threads 8 `
 --flash-attn `
 --port 8080

--n-gpu-layers 99: Descarga (offload) todas las capas posibles a la VRAM de la GPU.
--flash-attn: Habilita FlashAttention 3, logrando una mejora en la velocidad de inferencia y una reducción en el consumo de VRAM por parte de la caché KV.

7. Interfaz gráfica (GUI): Construcción de LM Studio y RAG local

Si no te sientes cómodo con la línea de comandos o si deseas realizar RAG (Generación Aumentada por Recuperación) de manera intuitiva, puedes usar una GUI.

7.1 LM Studio

LM Studio es una excelente aplicación que integra la búsqueda y descarga de modelos, verificación previa de los requisitos del sistema y una interfaz de chat. Simplemente con presionar el botón “Local Server” en la aplicación, se levantará una API compatible con OpenAI.

7.2 Arquitectura RAG usando AnythingLLM

Este es un diagrama de la arquitectura de un entorno RAG para cargar documentos internos o notas personales.

graph LR Document["Documentos (PDF, MD)"] --> Chunking["División en fragmentos (Chunking)"] Chunking --> EmbedModel["Modelo de incrustación (Embedding)"] EmbedModel --> VectorDB["Base de datos vectorial"] UserQuery["Consulta del usuario"] --> EmbedQuery["Incrustación de la consulta"] EmbedQuery --> VectorDB VectorDB --> |"Búsqueda de similitud"| RetrievedDocs["Extracción de documentos relevantes"] UserQuery --> PromptBuilder["Generador de prompts"] RetrievedDocs --> PromptBuilder PromptBuilder --> LocalLLM["LLM local"] LocalLLM --> Answer["Respuesta final"]

Si usas la versión de escritorio de AnythingLLM (Windows), simplemente configurando Ollama (LLM y Embedding) desde la pantalla de configuración y utilizando la VectorDB local (LanceDB), esta arquitectura se completará en minutos. Así nace una IA privada que no envía ningún dato al exterior.

8. Fine-tuning en Windows WSL2 (LoRA)

Si además de ejecutarlo localmente quieres que el modelo sea más inteligente con tus propios datos, es posible realizar fine-tuning mediante LoRA (Low-Rank Adaptation). En 2026, utilizando la biblioteca “Unsloth”, se puede completar el entrenamiento de un modelo 8B en unas pocas horas en un entorno WSL2 de Windows, incluso con 16 GB de VRAM.

Ejecuta lo siguiente dentro de Ubuntu en WSL2 para preparar el entorno:

1
2
3
4


conda create --name unsloth_env python=3.11
conda activate unsloth_env
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes

Unsloth optimiza los núcleos CUDA al extremo, y en comparación con la biblioteca estándar de Hugging Face, la velocidad de entrenamiento es aproximadamente el doble, mientras que el consumo de VRAM se reduce a la mitad. Al abrir un Jupyter Notebook y cargar un conjunto de datos (formato JSONL), el entrenamiento de varias épocas es posible incluso en una RTX 4060 Ti con 12 GB-16 GB de VRAM.

9. Resolución de problemas de rendimiento

Estos son los problemas más frecuentes a los que te puedes enfrentar y sus soluciones.

1. La velocidad de inferencia es extremadamente lenta (1-2 tokens/s)

Causa: El modelo no cabe en la VRAM y se está descargando (offloading) a la memoria del sistema (RAM). Solución: Verifica la “Memoria dedicada de la GPU” en el Administrador de tareas. Si se ha alcanzado el límite, reduce el tamaño del contexto (-c) o utiliza un modelo con cuantización de menos bits (como Q4_K_M).

2. Error de “CUDA out of memory”

Causa: La VRAM se ha agotado por completo. Esto ocurre especialmente cuando la interacción se prolonga y la caché KV aumenta de tamaño. Solución: Limita intencionadamente el valor de num_ctx en el caso de Ollama, o de -c en el caso de llama.cpp a un número menor.

3. La generación en japonés (u otro idioma) es extraña

Causa: Incompatibilidad en la plantilla del prompt, o el modelo no es compatible. Solución: Asegúrate de usar un modelo que contenga Instruct en su nombre y verifica que la herramienta tenga seleccionada la plantilla correcta especificada por el creador del modelo, como el formato ChatML o Llama3.

10. Conclusión y perspectivas de futuro

En 2026, la construcción de un LLM local en un entorno Windows ya no es un privilegio reservado para unos pocos ingenieros. Gracias a la estandarización del formato GGUF, la aparición de ecosistemas sofisticados como Ollama o LM Studio y las optimizaciones de hardware como FlashAttention, cualquier persona puede obtener fácilmente un entorno de IA de nivel empresarial.

Aprovecha los siguientes puntos explicados en este artículo:

Elegir lógicamente el tamaño del modelo y el nivel de cuantización óptimos para las especificaciones de tu PC utilizando el cálculo matemático de la VRAM.
Construir el entorno lo más rápido posible con Ollama y mejorar drásticamente la productividad vinculándolo con un editor de IA.
Extraer el rendimiento límite del hardware mediante el control avanzado de parámetros en llama.cpp.
Construir un sistema RAG local y seguro para manejar datos confidenciales con AnythingLLM.
Fomentar tu propia IA personalizada con conocimientos especializados aprovechando Unsloth (WSL2).

La “democratización” de la IA ya no es una palabra de moda; es un sistema real que funciona en tu escritorio de Windows. Libérate de los costes de uso de API en la nube y los riesgos de filtración de información, e ingresa hoy mismo al poderoso y libre mundo de la IA privada.