# Llama 3.3 70B en local: la cuenta de memoria, hardware y velocidad

> Qué hace falta para ejecutar Llama 3.3 70B en local: archivos, la cuenta de memoria por contexto, hardware y velocidades publicadas. No lo hemos ejecutado.

- Publicado: 2026-09-09
- Revisado: 2026-11-15
- Autor: Jacobo González Jaspe
- Idioma: es
- Etiquetas: Análisis de Modelo, Llama 3.3, IA Local, Hardware, Cuantización
- URL canónica: https://vorluxai.com/blog/llama-3-3-70b-local-review-what-it-takes-to-run-es/
- Fuente: VORLUX AI (J4SGON S.L.), https://vorluxai.com/

---

Al terminar esta guía sabrás si Llama 3.3 70B cabe en tu máquina, qué necesitarías si no cabe, qué velocidad esperar y si te conviene más un modelo pequeño. Para seguirla basta una calculadora; para ejecutarlo no basta un portátil de 16 GB.

Antes de nada: **no hemos ejecutado Llama 3.3 70B.** Nuestras máquinas son compartidas y preferimos no arriesgarlas con una carga de 43 GB. Esto no es el informe de una prueba. Los datos del modelo salen de Meta y de los repositorios de archivos; las cifras de memoria, de una cuenta contrastada con cargas reales de otros modelos; las velocidades del 70B, de terceros con nombre. Nosotros medimos los modelos más grandes que usamos.

> **TL;DR**
> - El archivo habitual (Q4_K_M) pesa 42,52 GB. Súmale 2,68 GB de caché de contexto a 8k y cerca de 1 GB de búferes: cuenta con 46 GB.
> - Cabe en 64 GB de memoria unificada. En 48 GB (una tarjeta, o dos de 24 GB) solo con contexto corto. En una tarjeta de 24 GB no cabe con una calidad aprovechable.
> - Velocidades publicadas de un 70B en Q4_K_M: 4,4 tokens por segundo en una DGX Spark y de 16 a 19 en dos tarjetas de 24 GB. En nuestras Spark medimos de 68 a 76 con modelos más nuevos de 26B y 35B.
> - Veredicto: si empiezas hoy, prueba antes un modelo mediano reciente. Compra para un 70B solo si tu prueba dice que ese no llega.

## Los datos del modelo

De la [ficha del modelo](https://huggingface.co/meta-llama/Llama-3.3-70B-Instruct) de Meta, leída el 15-11-2026:

| Dato | Valor |
|---|---|
| Publicación | 6 de diciembre de 2024 |
| Tipo | Modelo denso de texto: entra texto, sale texto y código. Sin imágenes. |
| Parámetros | 70.000 millones (el archivo de 16 bits pesa 141,12 GB: 70.600 millones a dos bytes cada uno) |
| Contexto | 128k tokens (131.072 en su `config.json`) |
| Idiomas admitidos | Inglés, alemán, francés, italiano, portugués, hindi, español y tailandés |
| Corte de conocimiento | Diciembre de 2023 |
| Licencia | Llama 3.3 Community License |

Dos consecuencias para una oficina española. El español está en la lista; fuera de ella, la ficha desaconseja usarlo sin ajuste fino y controles propios. Y el modelo no sabe nada posterior a 2023: las normas o los precios vigentes tienen que venir de tus documentos.

La tabla de Meta le da 68,9 en MMLU Pro frente a 48,3 de Llama 3.1 8B, y 92,1 en seguimiento de instrucciones (IFEval) frente a 80,4. Son cifras de Meta, en las condiciones de Meta.

## Qué quiere decir «abierto» aquí

Esto es información, no asesoramiento jurídico. Leímos la [licencia](https://dev.meta.ai/llama/llama3_3/license) y la [política de uso aceptable](https://dev.meta.ai/llama/llama3_3/use-policy) el 15-11-2026; léelas tú antes de que un cliente dependa del modelo.

Los pesos se descargan gratis y admiten uso comercial: eso es lo «abierto». Pero la ficha llama a la licencia «a custom commercial license»: es un acuerdo de Meta, no Apache ni MIT. Lo que pide:

- **Si redistribuyes el modelo o un producto que lo contiene** (sección 1.b): entregar una copia del acuerdo, mostrar «Built with Llama» en un lugar visible y conservar el aviso de atribución.
- **Si lo usas para entrenar o mejorar otro modelo que distribuyes**: el nombre de ese modelo debe empezar por «Llama».
- **Por encima de 700 millones de usuarios activos al mes** (sección 2) hace falta una licencia aparte de Meta.
- **La política de uso aceptable te obliga** (sección 1.b.iv), y Meta puede terminar la licencia si incumples el acuerdo (sección 6). Rige la ley de California (sección 7).

De la política de uso, lo que toca a una oficina: no ejercer una profesión sin habilitación (1.d), ningún uso militar ni en infraestructuras críticas (2.a y 2.d), no presentar la salida como escrita por una persona (3.e) y avisar a los usuarios finales de los peligros conocidos de tu sistema (4).

La política también retira la licencia a las personas y empresas con sede en la UE para los modelos *multimodales*. Llama 3.3 70B es solo de texto, así que, tal como lo leemos, esa cláusula no le alcanza.

El repositorio de Meta en Hugging Face tiene acceso restringido: antes de descargar aceptas la licencia y das tus datos de contacto.

## Tamaño de los archivos según la cuantización

Tamaños del [repositorio GGUF de bartowski](https://huggingface.co/bartowski/Llama-3.3-70B-Instruct-GGUF), leídos de su lista de archivos el 15-11-2026. Las notas de calidad son suyas, con nuestras palabras. Las etiquetas, de la [lista de Ollama](https://ollama.com/library/llama3.3/tags), mismo día.

| Cuantización | Archivo | Etiqueta en Ollama | Nota del repositorio |
|---|---|---|---|
| Q8_0 | 74,98 GB | `llama3.3:70b-instruct-q8_0` | La máxima calidad, casi siempre más de lo necesario |
| Q6_K | 57,89 GB | `llama3.3:70b-instruct-q6_K` | Casi perfecta, recomendada |
| Q5_K_M | 49,95 GB | `llama3.3:70b-instruct-q5_K_M` | Alta calidad, recomendada |
| Q4_K_M | 42,52 GB | `llama3.3:70b` (por defecto) | Buena calidad, la opción habitual |
| IQ4_XS | 37,90 GB | no hay | Aceptable, recomendada |
| Q2_K | 26,38 GB | `llama3.3:70b-instruct-q2_K` | Calidad muy baja, pero utilizable |
| IQ2_XXS | 19,10 GB | no hay | Calidad muy baja |

Ollama redondea la suya a 43 GB. Cómo elegir entre estas siglas está en nuestra guía para [elegir el archivo GGUF](https://vorluxai.com/blog/gguf-quantization-pick-the-right-file-for-your-hardware-es/). No tenemos medidas propias de calidad de estos archivos.

## La cuenta de memoria

El archivo no es toda la factura. El método es el de nuestra [guía de VRAM](https://vorluxai.com/blog/cuanta-vram-necesito-llm-local-es/), donde la cuenta coincidió al megabyte con 13 cargas reales de modelos menores ([registro de cargas](https://vorluxai.com/data/measurements/llama-load-log-buffers-2026-11-15.json)):

```
memoria = pesos (el archivo) + caché de contexto × ranuras en paralelo + búferes de cómputo
```

### Paso 1: lee los tres valores

La caché depende de las capas, las cabezas KV y la dimensión de cabeza, que están en el `config.json`. Esto lee una copia de acceso libre:

```bash
curl -sL https://huggingface.co/unsloth/Llama-3.3-70B-Instruct/raw/main/config.json | python3 -c "
import sys, json
c = json.load(sys.stdin)
for k in ('num_hidden_layers', 'num_key_value_heads', 'head_dim', 'hidden_size', 'vocab_size'): print(k, '=', c[k])"
```

Lo que nos devolvió el 15-11-2026:

```
num_hidden_layers = 80
num_key_value_heads = 8
head_dim = 128
hidden_size = 8192
vocab_size = 128256
```

### Paso 2: la caché, según el contexto

Cada token guarda un vector K y otro V por capa, a 16 bits: 80 × 8 × 128 × 2 × 2 = 327.680 bytes por token. Es dos veces y media lo de Llama 3.1 8B, y la cuantización del archivo no lo cambia.

```python
FILE_GB = 42.52                                    # Q4_K_M file
per_token = 80 * 8 * 128 * 2 * 2                   # bytes
for ctx, slots in [(4096, 1), (8192, 1), (16384, 1), (32768, 1), (131072, 1), (8192, 8)]:
    cache = per_token * ctx * slots / 1e9
    print(f"{ctx:>7} x {slots}: cache {cache:5.2f} GB, weights + cache {FILE_GB + cache:6.2f} GB")
```

Lo ejecutamos (no carga nada):

```
   4096 x 1: cache  1.34 GB, weights + cache  43.86 GB
   8192 x 1: cache  2.68 GB, weights + cache  45.20 GB
  16384 x 1: cache  5.37 GB, weights + cache  47.89 GB
  32768 x 1: cache 10.74 GB, weights + cache  53.26 GB
 131072 x 1: cache 42.95 GB, weights + cache  85.47 GB
   8192 x 8: cache 21.47 GB, weights + cache  63.99 GB
```

Con los 128k completos, la caché pesa tanto como el modelo.

### Paso 3: las ranuras

La última línea es el mismo modelo atendiendo a ocho personas a la vez. Las [preguntas frecuentes de Ollama](https://docs.ollama.com/faq) dicen que la memoria necesaria crece con `OLLAMA_NUM_PARALLEL` por la longitud del contexto; por defecto es 1. Cada usuario más a 8k le cuesta a este modelo 2,68 GB. Nuestra segunda máquina tiene ocho ranuras, y allí un modelo de 24B pasó de 19,79 GB a 25,64 GB cargado solo por doblar el contexto de 4k a 8k ([4k](https://vorluxai.com/data/measurements/mistral-small-24b-speed-ctx4k-2026-11-15.json), [8k](https://vorluxai.com/data/measurements/mistral-small-24b-speed-ctx8k-2026-11-15.json)).

### Paso 4: los búferes, y lo que `ollama ps` no cuenta

llama.cpp reserva además memoria de trabajo: de 112 a 912 MiB en nuestros registros, según el lote y las ranuras. Para un 70B reservamos 1 GB: un margen, no una medida de este modelo.

Después, `ollama ps` puede enseñarte *menos* que el tamaño del archivo. Informa de los búferes de la GPU, y la tabla de embeddings se queda en el lado del anfitrión. En nuestra carga de Llama 3.1 8B esa tabla ocupa 281,81 MiB: sus 128.256 × 4.096 valores a 4,5 bits cada uno. El 70B tiene 128.256 × 8.192. Guardados igual, son 0,59 GB que no salen en `ollama ps` y siguen en memoria. No lo hemos comprobado en una carga real.

## Qué cabe en cada máquina

Cuenta para planificar en Q4_K_M con una ranura (archivo + caché + 1 GB): 44,86 GB a 4k, 46,20 GB a 8k, 54,26 GB a 32k y 86,47 GB a 128k. Como en la guía de VRAM, a una tarjeta le restamos 0,5 GB y a la memoria unificada de más de 32 GB, 6 GB. «Justo» es más del 85 % de lo que queda.

| Memoria de la máquina | Utilizable | 4k | 8k | 32k | 128k |
|---|---|---|---|---|---|
| Una tarjeta de 24 GB | 23,5 GB | no | no | no | no |
| Una tarjeta de 32 GB | 31,5 GB | no | no | no | no |
| Dos tarjetas de 24 GB | 47 GB | justo | justo | no | no |
| Una tarjeta de 48 GB | 47,5 GB | justo | justo | no | no |
| 64 GB unificados | 58 GB | sí | sí | justo | no |
| 96 GB unificados | 90 GB | sí | sí | sí | justo |
| 128 GB unificados | 122 GB | sí | sí | sí | sí |

Cómo leerla:

- **24 y 32 GB.** En 24 GB solo cabe IQ2_XXS (21,44 GB a 4k) y en 32 GB, Q2_K (30,06 GB a 8k, justo). El repositorio da a los dos una calidad muy baja. Ahí rinde más un buen 24B en Q4.
- **48 GB.** Q4_K_M funciona hasta 8k casi sin margen; a 16k la cuenta da 48,89 GB y queda fuera. IQ4_XS deja sitio: 44,27 GB a 16k. Dos tarjetas no son una sola bolsa, porque cada capa va entera a una u otra: cuenta con menos margen. No hemos hecho ninguna carga repartida.
- **64 GB unificados.** El primer tamaño en que va holgado. Q5_K_M también cabe hasta 16k (56,32 GB, justo).
- **128 GB unificados.** Q8_0 a 32k son 86,72 GB. Pero «128 GB» no son 128 libres: nuestras máquinas dan 121,7 GB en total y, con sus servicios habituales, tenían de 65,4 a 75,1 GB disponibles antes de las cargas de nuestros registros ([primera máquina](https://vorluxai.com/data/measurements/dgx-spark-review-prime-2026-11-02.json), [segunda](https://vorluxai.com/data/measurements/mistral-small-24b-speed-ctx4k-2026-11-15.json)). Por eso no cargamos este modelo.

## El hardware que lo aguanta

Datos de fabricante, leídos el 15-11-2026:

- **Dos tarjetas de 24 GB.** La [comparativa de NVIDIA](https://www.nvidia.com/en-us/geforce/graphics-cards/compare/) da 24 GB a la RTX 3090 y a la RTX 4090, con 350 W y 450 W por tarjeta, y 32 GB y 575 W a la RTX 5090. Según las preguntas frecuentes de Ollama, un modelo que no cabe en una GPU se reparte entre todas las disponibles.
- **Una tarjeta de 48 GB.** La [gama profesional de NVIDIA](https://www.nvidia.com/en-us/products/workstations/professional-desktop-gpus/) tiene la RTX A6000 y la RTX 6000 Ada con 48 GB y 300 W, la RTX PRO 5000 Blackwell con 48 o 72 GB y la RTX PRO 6000 Blackwell con 96 GB.
- **Memoria unificada, Apple.** El [MacBook Pro](https://www.apple.com/macbook-pro/specs/) con M5 Max (GPU de 40 núcleos) se vende con 48, 64 o 128 GB y 614 GB/s de ancho de banda de memoria. El [Mac Studio](https://www.apple.com/mac-studio/specs/) con M5 Ultra va de 96 a 512 GB, con 1,2 TB/s. macOS limita cuánta puede ocupar la GPU: mira la guía de VRAM.
- **Memoria unificada, NVIDIA.** La [DGX Spark](https://www.nvidia.com/en-us/products/workstations/dgx-spark/), la máquina que tenemos, lleva 128 GB y 273 GB/s.

El ancho de banda está en la lista por algo. Un modelo denso lee todos sus pesos en cada token: el ancho de banda dividido entre el tamaño del archivo pone techo a la velocidad de un usuario: 273 ÷ 42,52 son 6,4 tokens por segundo en una Spark, por mucha memoria que sobre. Qué comprar con cada presupuesto: nuestro [catálogo de hardware](https://vorluxai.com/blog/local-ai-hardware-catalog-2026-what-to-buy-at-each-budget-es/).

## Qué velocidad esperar

**Publicado por otros.** Ninguna cifra es de Llama 3.3: son los 70B anteriores de la misma familia en Q4_K_M.

| Hardware | Generación | Fuente y condiciones |
|---|---|---|
| DGX Spark, 128 GB unificados | 4,42 tok/s | [Blog de Ollama](https://ollama.com/blog/nvidia-spark-performance), 23-10-2025: llama3.1:70b, Ollama 0.12.6, 500 tokens de salida |
| Dos RTX 3090 | 16,29 tok/s | [Repositorio de pruebas de XiongjieDai](https://github.com/XiongjieDai/GPU-Benchmarks-on-LLM-Inference): Llama 3 70B, `llama-bench`, 1.024 tokens, mayo de 2024 |
| Dos RTX 4090 | 19,06 tok/s | la misma |
| RTX A6000, 48 GB | 14,58 tok/s | la misma |
| RTX 6000 Ada, 48 GB | 18,36 tok/s | la misma |
| M3 Max (GPU de 40 núcleos), 64 GB | 7,53 tok/s | la misma |
| Una RTX 3090 o una RTX 4090 | sin memoria | la misma |

Las cifras del repositorio son de software de 2024, y las tarjetas, de máquinas alquiladas: tómalas como orden de magnitud.

**Medido por nosotros**, con el protocolo de nuestra [guía de 30 minutos](https://vorluxai.com/blog/benchmark-modelo-local-tu-ordenador-30-minutos-es/): un prompt de 278 palabras, 200 tokens de salida y la segunda ejecución. El 8B corrió en nuestra primera Spark (Ollama 0.30.10); los otros tres, en la segunda (Ollama 0.34.0, ocho ranuras).

| Modelo (Q4_K_M) | Archivo | Generación | Primer token | Registro |
|---|---|---|---|---|
| llama3.1:8b, denso | 4,92 GB | 43,7 tok/s | 0,385 s | [2-11-2026](https://vorluxai.com/data/measurements/dgx-spark-review-prime-2026-11-02.json) |
| mistral-small:24b, denso | 14,33 GB | 14,4 tok/s | 0,36 s | [15-11-2026](https://vorluxai.com/data/measurements/mistral-small-24b-speed-ctx4k-2026-11-15.json) |
| gemma4:26b, mezcla de expertos | 17,99 GB | 68,2 tok/s | 0,212 s | [2-11-2026](https://vorluxai.com/data/measurements/dgx-spark-review-spark2-2026-11-02.json) |
| qwen3.6:35b, mezcla de expertos | 23,94 GB | 75,8 tok/s | 0,243 s | el mismo |

[Mistral Small 24B](https://vorluxai.com/blog/mistral-small-24b-instruct-2501-es/) es nuestra referencia más cercana: denso, como el 70B, y medido hoy. Si la velocidad cayera en proporción al tamaño del archivo, sus 14,4 tokens por segundo se quedarían en 4,9 con uno de 42,52 GB. Es una cuenta, no una medida, y cae al lado de los 4,42 que publica Ollama.

Las dos filas más rápidas son los archivos más grandes que usamos. Son modelos de mezcla de expertos, que leen solo una parte de sus pesos en cada token. Una respuesta de 500 tokens tarda unos 113 segundos a 4,42 tokens por segundo, 26 a 19,06 y menos de 7 a 75,8.

## Si lo ejecutas: los comandos y las comprobaciones

No los hemos ejecutado con este modelo. Son los que usamos a diario con otros, en [Ollama](https://vorluxai.com/blog/instalar-ollama-primer-llm-local-es/).

1. Haz la cuenta con tu contexto y tus ranuras. Si no cabe, para aquí.
2. Fija el contexto antes de la primera carga. La [página de longitud de contexto de Ollama](https://docs.ollama.com/context-length) pone el valor por defecto según la memoria: 4k por debajo de 24 GiB, 32k entre 24 y 48, 256k a partir de 48.

```bash
OLLAMA_CONTEXT_LENGTH=8192 ollama serve
ollama pull llama3.3:70b
ollama run llama3.3:70b "Resume esta cláusula en tres viñetas: ..."
```

3. Comprueba dónde ha quedado:

```bash
ollama ps
```

La columna `PROCESSOR` debe decir `100% GPU` y `CONTEXT`, el valor que fijaste. El ejemplo de las preguntas frecuentes para un modelo que no cupo es `48%/52% CPU/GPU`.

4. Compara el registro de carga con tu cuenta (el comando está en la guía de VRAM) y cronometra con tu propio prompt, descartando la primera ejecución.

## Lo que sale mal

- **El contexto por defecto.** En un equipo de 48 GB, 32k son 10,74 GB de caché: la cuenta da 54,26 GB y parte del modelo se va a la CPU. Con los 131.072 tokens completos, solo la caché son 42,95 GB por ranura. Fíjalo tú.
- **Un reparto CPU/GPU en `ollama ps`.** Acorta el contexto, quita ranuras o baja de archivo, por ese orden: las capas que quedan en la CPU frenan a las demás. No tenemos cifras propias de un reparto.
- **La memoria unificada se agota.** En nuestras máquinas el síntoma fue un escritorio congelado y `NV_ERR_NO_MEMORY` en el registro del controlador (está en el análisis de la DGX Spark). Mira antes la memoria disponible, no la total.

## Cuándo es mejor un modelo más pequeño

Más veces de las que sugieren las tablas de pruebas. Lo que medimos:

- **Extracción.** Con 40 facturas españolas sintéticas, gemma4:26b acertó 360 de 360 campos; los modelos de 7B y 8B, entre 321 y 344 ([registro](https://vorluxai.com/data/measurements/structured-extraction-2026-11-05.json), [método](https://vorluxai.com/blog/ollama-salida-json-facturas-medido-es/)). Un archivo de 17,99 GB no dejó nada que un 70B pudiera mejorar en esa prueba.
- **Redacción en español.** Mistral Small 24B resolvió nuestras tres tareas de oficina (un correo, un resumen y una factura a JSON); ningún modelo de 7B u 8B lo hizo. El correo le llevó 20,3 segundos, frente a los 7,7 de llama3.1:8b ([respuestas](https://vorluxai.com/data/measurements/mistral-small-24b-spanish-2026-11-15.json), [notas](https://vorluxai.com/data/measurements/mistral-small-24b-spanish-2026-11-15-scores.json)). Las puntuó un solo lector, no un panel.
- **La espera.** La tabla de velocidades de arriba.

Prueba un 8B y después uno mediano con tus documentos. Pasa a un 70B solo si el fallo es de los que arregla el tamaño y la espera te vale. Un 70B se gana el sitio en una cola nocturna antes que en una ventana de chat.

## ¿Lo han superado?

En lanzamientos, sí. Lo documentado, leído el 15-11-2026:

- **La propia Meta.** [Llama 4](https://ai.meta.com/blog/llama-4-multimodal-intelligence/) llegó el 5 de abril de 2025: Scout (109.000 millones de parámetros en total, 17.000 millones activos) y Maverick (400.000 millones en total). Los dos son multimodales y más grandes: no son una opción local más fácil. La nota de Meta presenta a Maverick como alta calidad a menor precio que Llama 3.3 70B.
- **Un modelo de Meta más pequeño, con Apache 2.0.** [Muse Glimmer 30B](https://huggingface.co/meta-models/Muse-Glimmer-30B) apareció en agosto de 2026. Su ficha nombra como autor al Superintelligence Lab de Meta y da unos 29.600 millones de parámetros, corte de conocimiento en enero de 2026 y una versión de 4 bits de menos de 20 GB. Para [Artificial Analysis](https://artificialanalysis.ai/articles/muse-glimmer) es el primer modelo de pesos abiertos de Meta desde Llama 4. La ficha no lo compara con Llama 3.3 ni nombra el español entre sus idiomas.
- **Otros fabricantes.** La [página de Gemma 4](https://ollama.com/library/gemma4) en la biblioteca de Ollama da un 82,6 % en MMLU Pro para el 26B; la ficha de Meta da 68,9 a Llama 3.3 70B. Son laboratorios y condiciones distintos: un indicio, no una medida.

No sabemos cómo queda Llama 3.3 70B frente a estos en tu trabajo: no lo hemos ejecutado. Sí que los modelos de 26B y 35B que usamos tienen archivos de menos de 24 GB y son muchas veces más rápidos que la cifra publicada del 70B en nuestra clase de máquina.

Razones para elegirlo todavía: un flujo o un ajuste fino ya validados con él, necesitar un modelo solo de texto con el español en su lista, o un hardware que ya tienes.

## Preguntas frecuentes

**¿Puedo ejecutarlo en una RTX 4090?** No con una calidad que merezca la pena. El repositorio de pruebas citado anota falta de memoria para Q4_K_M en una tarjeta de 24 GB, y el único archivo que cabe es de calidad muy baja.

**¿Bastan 64 GB de RAM sin GPU?** La cuenta es la misma, así que debería cargar, pero todo corre en la CPU. No tenemos cifras y no contaríamos con ello.

**¿Va más lento en Q5 o Q8?** Por el ancho de banda, sí. En la tabla de Ollama para la Spark, los archivos Q8 de modelos densos más pequeños corrieron a unos dos tercios de la velocidad de Q4. Del 70B no hay cifra.

## Límites

No hemos ejecutado el modelo: no hay velocidad, tamaño cargado ni juicio de calidad nuestros. La cuenta de memoria está verificada con modelos de 7B a 24B, no con este, y el gigabyte de búferes es un margen. Las velocidades publicadas son de Llama 3 y 3.1 70B con software antiguo. No tenemos Mac, tarjeta dedicada ni carga repartida propias.

## Próximos pasos

- Haz la cuenta completa de cualquier modelo con la [guía de VRAM](https://vorluxai.com/blog/cuanta-vram-necesito-llm-local-es/).
- Mira qué modelos probaríamos antes en [mejores LLM locales según hardware y tarea](https://vorluxai.com/blog/mejores-llm-locales-segun-hardware-tarea-es/).
- Lee qué dan los modelos más grandes que usamos en nuestro [análisis de la DGX Spark](https://vorluxai.com/blog/dgx-spark-review-7-semanas-medido-es/).

## Hablemos 15 minutos

Hacemos esta cuenta con tus documentos y tu número de usuarios, y probamos primero los modelos pequeños, antes de recomendar hardware. Si lo quieres para tu empresa, [pide una llamada de 15 minutos](https://vorluxai.com/contact/?ref=llama-3-3-70b-local-review-what-it-takes-to-run-es) o mira [cómo trabajamos en consultoría](https://vorluxai.com/consulting/).
