Ejecutar Llama 3, Mistral y Phi Localmente: Configuración de Hardware y Primera Inferencia

Puedes ejecutar un modelo de lenguaje capaz en tu portátil ahora mismo. No un modelo de juguete, sino algo que maneje tareas reales. Llama 3 8B, Mistral 7B y Phi 3.5 se ejecutan en hardware de consumo. La barrera ya no es la capacidad. Es saber qué herramienta, qué cuantización y qué 20 minutos de configuración funcionan realmente.

Por qué importan los LLM Locales Ahora

Durante tres años, la inferencia local significaba usar un modelo de 7B parámetros que se comportaba como GPT-3, o quemar 200 $ al mes en llamadas a la API. Eso cambió en 2024. Llama 3 8B (lanzado en julio de 2024) se comporta a nivel de GPT-3.5 en la mayoría de las tareas. Mistral 7B supera a GPT-3.5 en razonamiento. Phi 3.5 se ejecuta en 8 GB de RAM y maneja resúmenes, clasificación y revisión de código sin degradación obvia.

La ventaja práctica: cero costes de API para el desarrollo, latencia de inferencia inferior a 500 ms en hardware modesto y tus datos nunca salen de tu máquina. La pega: necesitas la cuantización correcta, la herramienta adecuada y expectativas realistas sobre las compensaciones entre velocidad y calidad.

Realidad del Hardware

Antes de descargar nada, necesitas saber con qué estás trabajando.

• RAM: Un modelo de 7B con cuantización de 4 bits necesita aproximadamente 6–8 GB. Con 8 bits: 14–16 GB. Sin cuantizar (float32): mínimo 30 GB. Probablemente usarás 4 bits.
• GPU: Opcional pero transformador. Una RTX 4060 (8 GB VRAM) ejecuta Llama 3 8B en 4 bits a más de 30 tokens/segundo. Sin GPU: la inferencia por CPU en un MacBook Pro M1 hace 5–8 tokens/segundo — aceptable para procesamiento por lotes, difícil para uso interactivo.
• Disco: Un modelo de 7B cuantizado a 4 bits ocupa 3–5 GB. Mantén 20 GB libres para descargas de modelos y espacio de trabajo.

Si estás en un MacBook Air M1/M2, detente aquí — Ollama (abajo) maneja toda la aceleración de GPU automáticamente. Si estás en Windows o Linux con una tarjeta RTX, la aceleración de GPU reduce el tiempo de inferencia 4–6 veces.

Ollama: El Camino Sin Fricción

Si quieres ejecutar un modelo en los próximos cinco minutos sin pelear con entornos Python, usa Ollama.

Descarga desde ollama.ai, ejecuta el instalador. Luego:

ollama run llama2

Eso es todo. Ollama descarga, cuantiza y sirve el modelo automáticamente en localhost:11434. Ahora tienes una API local compatible con la interfaz de chat de OpenAI.

Para ejecutar Mistral en su lugar:

ollama run mistral

Ollama descarga la cuantización recomendada (generalmente Q4_K_M — 4 bits, variante media) automáticamente. Sin archivos de configuración. Sin complicaciones con CUDA en Linux. En Mac, detecta la GPU automáticamente.

La limitación: Ollama abstrae las opciones de cuantización. Si necesitas Q2_K (VRAM ultra baja) o Q8_0 (máxima calidad), necesitarás el siguiente enfoque.

LM Studio: Control y Simplicidad

Para el 80% de los profesionales, Ollama es suficiente. Para el 20% restante — personas que trabajan con 4 GB de RAM, o que buscan compensaciones específicas de calidad/velocidad — LM Studio es el siguiente paso.

LM Studio te proporciona una GUI, un selector de cuantización y la misma API compatible con OpenAI que Ollama.

Instala desde lmstudio.ai. Abre la aplicación. Busca «Mistral 7B». Verás 15 versiones:

• Q2_K: 3.5 GB, ~2 tokens/segundo en CPU
• Q4_K_M: 5 GB, ~5 tokens/segundo en CPU
• Q6_K: 8 GB, ~3 tokens/segundo en CPU (mayor calidad que Q4)
• Q8_0: 14 GB, calidad casi original, más lento

Para la mayoría de trabajos, Q4_K_M es la respuesta por defecto. Es el punto óptimo entre calidad y uso de recursos que Ollama también elige por defecto.

Descarga el modelo, haz clic en «Load», y luego úsalo vía API:

import requests
import json

response = requests.post(
    "http://localhost:1234/v1/chat/completions",
    json={"model": "local-model", "messages": [{"role": "user", "content": "Summarize this in one sentence: [your text]"}], "temperature": 0.7}
)
print(response.json()['choices'][0]['message']['content'])

La API es idéntica a la de OpenAI. Eso importa — puedes probar localmente, luego cambiar el endpoint a GPT-4o sin reescribir código.

Cuándo Elegir Cada Modelo

Llama 3 8B, Mistral 7B y Phi 3.5 resuelven diferentes problemas con diferentes niveles de recursos.

• Phi 3.5 Mini (3.8B parámetros, 2 GB cuantizados): Se ejecuta en cualquier hardware. Mejor para clasificación, extracción, resúmenes. Pierde coherencia en generación abierta más allá de 1000 tokens.
• Mistral 7B (7B parámetros, 5 GB cuantizados): Razonamiento más fuerte para su tamaño. Mejor que Llama 3 en código y salida estructurada. Ligeramente más débil en escritura creativa.
• Llama 3 8B (8B parámetros, 6 GB cuantizados): El más equilibrado. Bueno en todo. Más lento que Mistral en CPU (mayor número de parámetros), pero más fiable en documentos largos.

Si tienes 8 GB de RAM: empieza con Phi 3.5. Si tienes 16 GB o una GPU: Mistral 7B. Si necesitas máxima flexibilidad: Llama 3 8B.

Pruébalo Hoy: Un Ejemplo Funcional

Instala Ollama. Ejecuta esto:

ollama run mistral

Espera 3–4 minutos para la descarga. Luego pega esto en el prompt:

Extrae las entidades de este texto como JSON. Devuelve solo JSON válido, sin explicaciones.

Texto: Apple lanzó el iPhone el 29 de junio de 2007. Steve Jobs lo presentó en San Francisco.

Formato de devolución: {"companies": [], "products": [], "dates": [], "people": []}

Obtendrás JSON válido en menos de 5 segundos en la mayoría del hardware. Eso es extracción — no alucinación, no deriva de generación. Una tarea real que solía requerir una llamada a la API. Ahora es local, gratuita y offline.

Ese prompt funciona porque está acotado (el formato JSON impone estructura) y Mistral 7B es fuerte en el seguimiento de instrucciones. Si intentas el mismo prompt en Phi 3.5, ocasionalmente podrías obtener JSON malformado — una diferencia cuantitativa que vale la pena conocer antes de construir sobre ello.

Siguiente Paso: Integrar en tu Flujo de Trabajo

Configura Ollama o LM Studio para que se ejecuten al inicio. Añade esto a tu entorno Python para cualquier pipeline de extracción o clasificación:

from openai import OpenAI

client = OpenAI(api_key="not-used", base_url="http://localhost:11434/v1")

def classify_text(text, categories):
    response = client.chat.completions.create(
        model="mistral",
        messages=[{
            "role": "user",
            "content": f"Clasifica este texto como uno de: {', '.join(categories)}

Texto: {text}"
        }]
    )
    return response.choices[0].message.content

Esa es tu capa de inferencia local. Es compatible con la API de OpenAI, sin coste y lista para uso en producción en tareas repetitivas donde la latencia de la velocidad de la luz no importa — procesamiento por lotes, trabajos en segundo plano, pipelines de clasificación.