Qwen 2.5 Coder 7B en tu propia máquina: instálalo, mídelo y ponlo a trabajar en 20 minutos
Al terminar este artículo tendrás Qwen 2.5 Coder 7B respondiendo en tu propia máquina, una cifra medida de tokens por segundo y tres prompts para usar el lunes: revisar un script, escribir SQL y refactorizar una función. El punto de partida más barato es un portátil con 16 GB de RAM. Sin cuenta, sin clave de API y con tu código sin salir del edificio.
Qué necesitas
- Una máquina de la tabla de abajo. El archivo del modelo ocupa 4,7 GB. En memoria ocupa 4,7 GB con el contexto de 4k por defecto de Ollama y 6,6 GB con 32k; los dos números salen de
ollama psen nuestra estación hoy. - Ollama, desde ollama.com/download.
- Veinte minutos, la mayoría de descarga.
| Máquina | ¿Cabe? | Qué esperar |
|---|---|---|
| Portátil, 16 GB de RAM, sin GPU dedicada | Sí, en la CPU | Un dígito de tokens por segundo. Con la GPU apagada, nuestra propia máquina dio 5,2 tok/s. Sirve para una pregunta cada vez. |
| Portátil o sobremesa con una NVIDIA de 8 GB | Sí, con 4k a 8k de contexto | Mantén num_ctx moderado para que el modelo entero se quede en la GPU. |
| Mac mini M4, 24 GB (~920 EUR) | Sí | ~35 tok/s con Qwen 2.5 7B (Compute Market) |
| Jetson Orin Nano Super, 8 GB (~250 EUR) | El 7B no: 4,7 a 6,6 GB en 8 GB compartidos con el sistema no dejan sitio | Usa qwen2.5-coder:3b (1,9 GB); los modelos de 3B llegan a 12-18 tok/s ahí (Edge AI Vision) |
| Nuestra estación GB10, 128 GB de memoria unificada | Sí | 33,4 tok/s, medido el 09-09-2026 |
Paso 1: instala y ejecuta
ollama run qwen2.5-coder:7bEso descarga la versión Q4_K_M de 4,7 GB con una ventana de contexto de 32K (ollama show qwen2.5-coder:7b imprime las dos cosas). Pregúntale algo y escribe /bye para salir. La página de Ollama lista tamaños desde 0.5b (398 MB) hasta 32b (20 GB). De la ficha del modelo: 7.610 millones de parámetros, licencia Apache 2.0, entrenado con 5,5 billones de tokens, contexto de 128K en los pesos de precisión completa, publicado en septiembre de 2024.
Paso 2: mídelo
curl -s localhost:11434/api/generate -d '{
"model": "qwen2.5-coder:7b",
"prompt": "Escribe una función en Python que valide un NIF español (DNI + letra). Devuelve solo el código con un docstring corto.",
"stream": false, "options": {"temperature": 0.2}
}' | python3 -c "import json,sys; d=json.load(sys.stdin); \
print(d['eval_count'],'tokens', round(d['eval_duration']/1e9,2),'s', \
round(d['eval_count']/(d['eval_duration']/1e9),1),'tok/s; carga', round(d['load_duration']/1e9,2),'s')"Nuestras ejecuciones del 9 de septiembre de 2026:
| Tarea | Tokens de salida | Tiempo de generación | Velocidad | Tiempo de carga |
|---|---|---|---|---|
| Escribir un validador de NIF | 231 | 6,92 s | 33,4 tok/s | 10,7 s (en frío) |
| Consulta SQL (tarea B) | 99 | 2,96 s | 33,5 tok/s | 0,20 s (en caliente) |
| Revisar un script (tarea A) | 450 | 13,47 s | 33,4 tok/s | 10,9 s (recargado) |
| Refactorizar una función (tarea C) | 309 | 13,41 s | 23,0 tok/s, con un segundo modelo cargado al lado | 48,6 s |
Una tanda anterior en la misma máquina dio 33,2 tok/s, 400 tokens en 12,0 s, carga en frío de 10,5 s y en caliente de 0,19 s. Los números son estables cuando la GPU está tranquila. La función del NIF que escribió era correcta, con su tabla de letras y su módulo 23. Si tu velocidad queda muy por debajo de la tabla de hardware, ejecuta ollama ps: quieres ver 100% GPU.
Paso 3: tres tareas, con los prompts exactos y lo que devolvió
Tarea A: revisión de código. Prompt: “Revisa este script de Python en busca de errores, problemas de seguridad y cualquier cosa que falle en una máquina Windows. Sé conciso: una lista numerada, lo más grave primero, con un arreglo de una línea para cada punto.”, seguido de un script de diez líneas que montaba el SQL con formato % y escribía en /tmp. El modelo devolvió seis hallazgos numerados, en el orden correcto: primero la inyección SQL, con el arreglo db.execute("INSERT INTO clients VALUES (?, ?)", r); después la ruta /tmp fija en Windows, la falta de manejo de errores, la ausencia de comprobación del argumento, la conexión sin cerrar y la cabecera del CSV. No se le escapó nada grave.
Tarea B: generación de SQL. Prompt: “Tablas: clientes(id, nombre, provincia), facturas(id, cliente_id, fecha, total, pagada). Escribe una consulta SQLite: total facturado y total pendiente de cobro por provincia en 2026, ordenado por pendiente descendente. Devuelve solo SQL.” Devolvió un join limpio con SUM(CASE WHEN f.pagada = 0 THEN f.total ELSE 0 END), su GROUP BY y el ORDER BY correcto, en tres segundos. Un defecto: el filtro era YEAR(f.fecha) = 2026, una función de MySQL que no existe en SQLite; la línea correcta es strftime('%Y', f.fecha) = '2026'. Repite el dialecto dos veces y prueba la consulta sobre una copia.
Tarea C: refactorización. Prompt: “Refactoriza esta función de Python para que sea legible y fácil de probar. Mantén el comportamiento idéntico. Usa anotaciones de tipo, sin estado global, y explica los cambios en tres puntos después del código.”, seguido de una función que leía i[1] e i[2] de filas de tres campos. El resultado tenía anotaciones de tipo, buenos nombres y los tres puntos, y estaba mal: desempaquetaba cada fila en dos campos, así que fallaría con los datos reales mientras afirmaba que el comportamiento era idéntico. Para refactorizar, pega una fila de ejemplo y una prueba, y ejecuta la prueba.
Dónde encaja, y los límites honestos
Dos de nuestras tres tareas volvieron con un defecto que un lector atento detecta en un minuto. Esa es la forma honesta de un modelo de código de 7B: un compañero junior, rápido y privado, cuyo trabajo lees antes de integrarlo. Es bueno revisando scripts pequeños, en SQL, en código repetitivo, en pruebas y explicando código ajeno. No razona sobre un repositorio entero, flojea con frameworks poco comunes y afirma cosas erróneas con seguridad. La propia ficha de Qwen dice que la versión de 32B iguala a GPT-4o; el 7B es el tamaño que cabe en un portátil, no esa afirmación. Reserva un modelo de primera línea para la arquitectura y la depuración difícil, y dale a este la parte rutinaria; el cálculo del punto de equilibrio muestra cuánto vale esa parte.
Paso 4: conéctalo a VS Code y a n8n
VS Code con Continue. Instala la extensión Continue y pon esto en ~/.continue/config.yaml, siguiendo la guía de Ollama de Continue:
models:
- name: Qwen2.5-Coder 7B
provider: ollama
model: qwen2.5-coder:7b
apiBase: http://localhost:11434
roles: [chat, edit]
- name: Qwen2.5-Coder 1.5B
provider: ollama
model: qwen2.5-coder:1.5b
roles: [autocomplete]La guía recomienda el 1.5b para autocompletar, donde la latencia importa más que la profundidad, y un modelo mayor para chat y ediciones. Apunta apiBase a la dirección de otra máquina para compartir un servidor en toda la oficina.
n8n. Crea una credencial de Ollama con Base URL http://localhost:11434, conecta un nodo Ollama Chat Model a un Basic LLM Chain y elige qwen2.5-coder:7b. Si n8n corre en Docker, la documentación de la credencial de Ollama en n8n explica cómo fijar OLLAMA_HOST para que el contenedor llegue al servidor. Nuestro tutorial de revisión de código con n8n convierte la tarea A en un paso automático en cada pull request.
Siguientes pasos
- Compáralo con los otros modelos locales que usamos: Mejores modelos LLM locales, comparativa del segundo trimestre de 2026.
- Elige la máquina: Mejores dispositivos para IA local en 2026.
- Automatiza la revisión: Tutorial de revisión de código con IA en n8n.
Trabaja con nosotros
Usamos este modelo a diario en nuestro propio hardware y lo dejamos montado en los clientes con los prompts, la configuración de VS Code y el flujo de n8n incluidos. Si quieres tenerlo funcionando en tus máquinas, escríbenos o mira cómo trabajamos en consultoría.