Puntos clave
- Las ejecuciones locales necesitan suficiente RAM o VRAM para el archivo cuantizado más la caché de contexto.
- Ollama es el inicio más rápido; llama.cpp ofrece más control sobre la cuantización y las banderas.
- Ambos exponen un servidor estilo OpenAI, por lo que el mismo código del cliente puede apuntar a local o alojado.
- Un endpoint alojado cuesta $0,15 por 1M de tokens de entrada y $0,50 por 1M de tokens de salida y se configura en minutos.
Decide primero: ¿qué hardware tienes?
La memoria lo decide todo. Un modelo de lenguaje es un conjunto muy grande de números, y todo el conjunto debe estar en memoria rápida mientras genera. La cuantización reduce esos números. Un modelo cuantizado en 4 bits ocupa aproximadamente medio byte por parámetro, por lo que un modelo con 8 mil millones de parámetros ocupa cerca de 5 GB, y uno con 70 mil millones cerca de 40 GB. Trata estas cifras como aproximadas, ya que el tamaño exacto depende del formato de cuantización.
Además de los pesos, necesitas espacio para la caché de contexto. Esta crece con la longitud del prompt, por lo que un historial largo de roleplay o un documento grande consumen más memoria que una pregunta corta. Calcula unos gigabytes extra con una ventana de contexto modesta, más si te acercas a prompts largos.
- Portátil con 8 GB y sin GPU: solo modelos pequeños, salida lenta.
- Mac con Apple Silicon de 16 a 32 GB: los modelos de tamaño medio funcionan bien porque la CPU y la GPU comparten memoria.
- GPU de consumo única con 12 a 24 GB de VRAM: modelos de tamaño medio a buena velocidad.
- Cualquier cosa más grande: múltiples GPUs o un servidor alquilado.
Método 1: Ollama en unos pocos comandos
Ollama es el camino más corto. Descarga un modelo cuantizado, inicia un servidor en segundo plano y te da un prompt de chat. Instálalo desde el sitio oficial para tu sistema operativo, luego comprueba qué etiquetas de Dolphin lista actualmente la biblioteca de modelos de Ollama, ya que los nombres y tamaños cambian entre versiones.
# replace <tag> with a Dolphin tag from the Ollama library
ollama pull <tag>
ollama run <tag>El primer comando descarga el archivo, lo cual puede tardar en una conexión lenta. El segundo abre un chat interactivo en la terminal. Ollama también sirve una API HTTP en tu máquina, incluyendo una ruta estilo OpenAI bajo /v1, para que otros programas puedan usarla.
Si la generación es muy lenta, es probable que el modelo no quepa en la VRAM y parte se ejecute en la CPU. Elige una etiqueta más pequeña o una cuantización de menor bit.
Método 2: llama.cpp para más control
llama.cpp es el motor en C++ sobre el que se basan muchas otras herramientas. Descargas un archivo GGUF del modelo, luego inicias su servidor. Esto requiere más pasos que Ollama pero te permite establecer la longitud del contexto, el número de capas colocadas en la GPU y la cuantización que desees.
# after building llama.cpp and downloading a GGUF file
llama-server -m ./model.gguf -c 8192 -ngl 99 --port 8080Aquí -c establece la longitud del contexto, -ngl establece cuántas capas van a la GPU, y --port selecciona el puerto. Consulta el README del proyecto para ver las banderas en tu versión, ya que evolucionan. Un -c más grande usa más memoria, así que aumentalo solo cuando lo necesites.
Para uso gráfico, frontends como Open WebUI pueden hablar con cualquiera de los servidores. Nuestra nota sobre endpoints de API de Open WebUI muestra cómo añadir un endpoint personalizado.
Llamando a tu servidor local desde código
Ambas herramientas pueden hablar el formato de chat de OpenAI, así que escribes el cliente una vez y cambias el destino con dos ajustes. Este script mantiene ambos destinos lado a lado. El local usa el puerto que Ollama usa por defecto; cámbialo si iniciaste llama.cpp en 8080.
from openai import OpenAI
TARGETS = {
"local": {"base_url": "http://localhost:11434/v1", "key": "not-needed", "model": "your-local-tag"},
"hosted": {"base_url": "https://api.dolphinllm.com/v1", "key": "YOUR_KEY", "model": "uncensored"},
}
t = TARGETS["hosted"]
client = OpenAI(base_url=t["base_url"], api_key=t["key"])
resp = client.chat.completions.create(
model=t["model"],
messages=[{"role": "user", "content": "Summarize what a GGUF file is."}],
)
print(resp.choices[0].message.content)Los servidores locales suelen ignorar la clave, pero el SDK requiere una cadena no vacía. El nombre del modelo para un servidor local es la etiqueta o alias que cargaste, mientras que el ID del modelo alojado es siempre uncensored.
Método 3: salta la configuración y usa un endpoint alojado
Si las matemáticas del hardware no son buenas, o quieres el mismo comportamiento en cada máquina, un endpoint alojado es más simple. Este servicio proporciona un modelo de pesos abiertos, ejecutado por un proveedor independiente y ajustado para responder sin rechazos de contenido para uso adulto legal. No es la API oficial de ningún proveedor de modelos, y no te permite elegir otros modelos. Lo que obtienes es una URL estable, una clave y facturación por token.
Los pasos son cortos. Regístrate con Google o con correo electrónico y contraseña, abre la página de clave de API, y reclama el crédito de prueba de $0,50 con un solo clic. No requiere tarjeta, es válido por 7 días y está limitado a uno por persona. Luego ejecuta el script de Python anterior con el destino alojado. Si prefieres curl:
curl https://api.dolphinllm.com/v1/chat/completions -H "Authorization: Bearer YOUR_KEY" -H "Content-Type: application/json" -d '{"model":"uncensored","messages":[{"role":"user","content":"Hello"}],"stream":false}'La ventana de contexto es de 100.000 tokens, lo cual es más de lo que la mayoría de los portátiles pueden mantener en caché cómodamente. Los prompts no se usan para entrenamiento.
Coste y esfuerzo comparados
Local parece gratis, pero no lo es. Pagas por hardware, electricidad y tu propio tiempo. Alojado cuesta dinero por petición, pero las cifras son pequeñas. A $0,15 por 1M de tokens de entrada y $0,50 por 1M de tokens de salida, una vuelta de chat con 3.000 tokens de entrada y 700 tokens de salida cuesta:
- Entrada: 3.000 x $0,15 / 1.000.000 = $0,00045
- Salida: 700 x $0,50 / 1.000.000 = $0,00035
- Total: $0,0008 por vuelta, es decir, $0,80 por 1.000 vueltas
Incluso un usuario intensivo que envíe 5.000 de estas vueltas en un mes gastaría unos $4. Una GPU que cuesta cientos de dólares tardaría años en amortizar esa inversión con ese volumen. La comparación cambia cuando tienes un volumen alto continuo, necesitas un ajuste fino específico o no puedes enviar datos fuera de tu máquina.
Los detalles completos de precios, incluidos los bonos de recarga del +5%, +10% y +15%, están en la página de precios, y la documentación cubre los límites y parámetros.
Una regla simple para elegir
Ejecuta el modelo localmente si quieres experimentar con varios fine-tunes, trabajar sin conexión o guardar todos los prompts en tu propio disco. Usa el endpoint alojado si estás construyendo algo que otras personas usarán, si tu hardware es modesto o si quieres una ventana de contexto de 100.000 tokens sin gestionar la memoria. Muchos desarrolladores hacen ambas cosas: un modelo local para experimentación privada y un endpoint alojado para cualquier servicio que deba estar disponible. Como el código del cliente es el mismo, cambiar de uno a otro requiere modificar una sola línea.
