Cómo Usar LLMs Locales como APIs

Su portátil puede servir un modelo de 70B parámetros detrás del mismo endpoint con forma de OpenAI que usted envía a producción. Cambie una URL base y su código seguirá funcionando. Ese único cambio desbloquea el desarrollo sin conexión, el costo cero por token y una ruta privada para datos regulados, razón por la cual Hacker News impulsó "La IA local debe ser la norma" de 633 a 1,760 puntos en un día. La pieza a continuación le muestra cómo elegir un tiempo de ejecución, exponer el endpoint, apuntar su cliente hacia él y probar todo el flujo con Apidog antes de promover cualquier cambio a un modelo alojado.

En resumen

Puede ejecutar una API LLM local en su portátil con Ollama, vLLM o llama.cpp, y cada uno de ellos expone un endpoint REST compatible con OpenAI. Cambie base_url a http://localhost:11434/v1 en su cliente OpenAI existente y el mismo código se ejecutará con Llama 3.3, DeepSeek V4 o Qwen 3.6 sin necesidad de reescribir. Conduzca todo el flujo desde Apidog para que sus pruebas de escenario se mantengan idénticas en entornos locales y alojados.

Introducción

La pila de API LLM locales pasó de ser un juguete de investigación a un motor diario en dieciocho meses. Apple lanzó 128 GB de memoria unificada en el M3 Max. Ollama alcanzó un millón de descargas semanales. vLLM superó la línea de 30,000 estrellas en GitHub. Sin embargo, el cambio más grande fue social. Cada tiempo de ejecución principal ahora habla la forma /v1/chat/completions de OpenAI. Ya no necesita mantener dos rutas de cliente. La misma llamada SDK llega a localhost o a api.openai.com según una variable de entorno.

Esto es importante para los desarrolladores de API porque sus herramientas existentes siguen funcionando. Sus plantillas de solicitud en Apidog apuntan a https://api.openai.com/v1/chat/completions. Cambie la variable de URL base, presione Enviar y obtendrá el mismo JSON de un modelo que se ejecuta en su propia GPU. Sin nuevo esquema. Sin nuevo flujo de autenticación. Si ya rastrea el gasto de API por función, puede hacer una prueba A/B de un modelo local frente a uno alojado y ver cómo la línea de costos disminuye mientras la latencia aumenta.

Esta guía recorre la elección del tiempo de ejecución, la configuración del servidor, la conexión del cliente, las pruebas de escenarios, las compensaciones de cuantificación y una tabla de costos vs. latencia para cuatro modelos actuales. Los ejemplos de código se prueban con Ollama 0.6 y vLLM 0.7 en macOS 15.4 y Ubuntu 24.04. Para obtener un panorama más amplio de las opciones, consulte Los mejores LLM locales de 2026. Las referencias externas para cada afirmación se encuentran al final.

button

Por qué los LLM locales tienen sentido para los desarrolladores de API

Usted envía código que llama a un LLM. También depura ese código en el avión, en conferencias con mala conexión Wi-Fi y dentro de redes de clientes que bloquean la salida a *.openai.com. Una API LLM local le proporciona un entorno de desarrollo que reproduce la producción sin la dependencia de la red.

La historia de la privacidad es la más ruidosa. HIPAA, GDPR y la Ley de IA de la UE tratan los prompts como datos de usuario en el momento en que incluyen notas de pacientes, contratos o identificadores biométricos. Enviar esa carga útil a un endpoint alojado crea una relación de procesamiento de datos que debe documentar, auditar y renovar. Un modelo que nunca sale de su hardware se salta todo ese papeleo. La guía de 2024 de la Junta Europea de Protección de Datos sobre el procesamiento de IA señala que la inferencia en el dispositivo elimina la mayoría de las obligaciones de transferencia transfronteriza según el Artículo 44.

El costo se agrava en la otra dirección. Un equipo que ejecuta 50 millones de tokens de prompt al día a través de GPT-5.5 Instant paga aproximadamente $250 por día a $5 por millón de tokens. El mismo volumen en un estudio M3 Max de $4,500 se amortiza a cero después de dieciocho días de utilización completa, ignorando la electricidad. Puede leer un desglose de esos números en Cómo usar GPT-5.5 Instant y aplicar la misma aritmética a su propia carga de trabajo.

La tercera razón es el determinismo. Los modelos alojados cambian los pesos a sus espaldas. La página de desuso de modelos de OpenAI enumera once retiradas de instantáneas en los últimos doce meses. Un modelo local es un archivo en el disco. Produce los mismos logits hoy y dentro de tres años. Esa estabilidad importa cuando su suite de regresión depende de la salida del LLM. El endpoint compatible con OpenAI cambió el juego porque ya no paga un impuesto de integración por esa estabilidad. El SDK que ya utiliza funciona.

Tres tiempos de ejecución que envían endpoints compatibles con OpenAI

Cuatro tiempos de ejecución dominan el espacio de las API LLM locales en 2026. Tres envían un servidor REST compatible con OpenAI de forma predeterminada. El cuarto, llama.cpp, envía uno como parte de su binario llama-server. Elija por carga de trabajo, no por popularidad.

Ollama

Ollama es la forma más fácil de empezar. Un binario, una CLI, un servidor HTTP en el puerto 11434. Está dirigido a desarrolladores que ejecutan un solo modelo en una sola máquina y maneja las descargas de modelos, la cuantificación GGUF y la creación de plantillas de prompts por usted.

## install on macOS
brew install ollama
ollama serve &
ollama pull llama3.3:70b-instruct-q4_K_M
ollama run llama3.3:70b-instruct-q4_K_M

Una vez que ollama serve está activo, el endpoint compatible con OpenAI se encuentra en http://localhost:11434/v1. Admite chat, embeddings y streaming. El rendimiento máximo en un M3 Max con un modelo 70B Q4_K_M ronda los 12 tokens por segundo. Los modelos más pequeños alcanzan entre 80 y 120 tokens por segundo. Ollama es la opción correcta para el desarrollo de un solo usuario, demostraciones y ejecutores de CI.

vLLM

vLLM es la opción de grado de producción. Utiliza PagedAttention y procesamiento por lotes continuo para aumentar el rendimiento de dos a cuatro veces en comparación con los ejecutores ingenuos. Sirve en el puerto 8000 por defecto y expone una API compatible con OpenAI en /v1. Puede leer los detalles de la arquitectura en el documento de vLLM en la referencia de Kwon et al. SOSP 2023 a continuación.

pip install vllm
vllm serve meta-llama/Llama-3.3-70B-Instruct \
  --port 8000 \
  --gpu-memory-utilization 0.9 \
  --max-model-len 8192

En una sola H100, vLLM sirve Llama 3.3 70B a aproximadamente 2,400 tokens por segundo en solicitudes concurrentes. Necesita una GPU CUDA o una tarjeta AMD ROCm reciente y no se ejecuta en Apple Silicon, lo que lo convierte en la opción incorrecta para portátiles y la opción correcta para clústeres de desarrollo compartidos.

llama.cpp

llama.cpp es el tiempo de ejecución de C++ que inició el ecosistema GGUF. Se ejecuta en todas partes, desde Raspberry Pi 5 hasta equipos con doble RTX-5090. Su binario llama-server habla la forma OpenAI en /v1/chat/completions.

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp && make -j LLAMA_METAL=1
./llama-server -m models/llama-3.3-70b-q4_k_m.gguf \
  --port 8080 --host 0.0.0.0 -c 8192 -ngl 99

La bandera -ngl 99 descarga todas las capas a la GPU. llama.cpp le brinda el mayor control sobre la cuantificación, el procesamiento por lotes y el mapeo de memoria. Es la opción correcta cuando necesita ajustar un modelo en 16 GB de VRAM o probar hardware exótico.

LM Studio y Jan envuelven llama.cpp en una GUI y también exponen un endpoint de OpenAI en un puerto configurable. Son útiles para usuarios no técnicos de su equipo que necesitan probar prompts sin tocar una terminal.

Una simple verificación en Python de que el endpoint funciona:

from openai import OpenAI
client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
resp = client.chat.completions.create(
    model="llama3.3:70b-instruct-q4_K_M",
    messages=[{"role": "user", "content": "Reply with the word OK only."}],
)
print(resp.choices[0].message.content)

Si ve OK, el tiempo de ejecución, el puerto y el contrato del SDK coinciden. Está listo para conectar el endpoint a sus herramientas.

Pruebe su LLM local con Apidog

Una API LLM local solo es útil si su suite de pruebas puede acceder a ella de la misma manera que accede a la producción. Apidog maneja esto con variables de entorno en la plantilla de solicitud, lo que significa que un solo proyecto cubre ambos objetivos.

Interfaz de Apidog mostrando la configuración de un entorno local

El flujo tiene cinco pasos.

Abra su proyecto Apidog y cree un nuevo entorno llamado Local. Añada una variable BASE_URL con el valor http://localhost:11434/v1. Añada API_KEY con el valor ollama. Guarde.
Clone su entorno OpenAI existente, renómbrelo a Production, mantenga BASE_URL como https://api.openai.com/v1 y API_KEY como su clave alojada.
En cualquier solicitud que llame a un endpoint de chat, reemplace el host codificado con {{BASE_URL}} y el encabezado de autenticación con Bearer {{API_KEY}}. La URL de la solicitud se convierte en {{BASE_URL}}/chat/completions.
Cree una prueba de escenario que dispare la solicitud, afirme que choices[0].message.role == "assistant", afirme que choices[0].message.content no está vacío y afirme que usage.total_tokens > 0. Guarde el escenario.
Ejecute el escenario contra Local. Cambie el menú desplegable de entorno a Production. Ejecute de nuevo. Las afirmaciones deberían pasar para ambos.

El mismo escenario sirve como prueba de humo para las actualizaciones del tiempo de ejecución. Después de ollama pull en una nueva etiqueta, vuelva a ejecutar el escenario Local. Si la forma de la respuesta varía, lo detectará antes de que cualquier código de aplicación toque los nuevos pesos. El patrón se extiende a la prueba de agentes de IA que llaman a APIs multi-paso.

Para uso programático, el SDK de Python de OpenAI cambia los objetivos con un argumento de palabra clave:

import os
from openai import OpenAI

def get_client():
    if os.getenv("ENV") == "local":
        return OpenAI(
            base_url="http://localhost:11434/v1",
            api_key="ollama",
        )
    return OpenAI(api_key=os.environ["OPENAI_API_KEY"])

client = get_client()
response = client.chat.completions.create(
    model=os.getenv("MODEL", "llama3.3:70b-instruct-q4_K_M"),
    messages=[
        {"role": "system", "content": "You are a JSON-only assistant."},
        {"role": "user", "content": "Return {\"status\": \"ok\"}."},
    ],
    response_format={"type": "json_object"},
)
print(response.choices[0].message.content)

La forma en JavaScript refleja esto:

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: process.env.ENV === "local"
    ? "http://localhost:11434/v1"
    : "https://api.openai.com/v1",
  apiKey: process.env.ENV === "local" ? "ollama" : process.env.OPENAI_API_KEY,
});

const resp = await client.chat.completions.create({
  model: process.env.MODEL || "llama3.3:70b-instruct-q4_K_M",
  messages: [{ role: "user", content: "Say hi." }],
});
console.log(resp.choices[0].message.content);

Conecte el ejecutor de escenarios de Apidog a su CI exportando el proyecto como una colección de apidog-cli y llamando a apidog run en GitHub Actions. El ejecutor devuelve un código de salida distinto de cero en caso de falla de una aserción, lo que detiene la compilación en el momento en que un contrato local o alojado diverge. Los ingenieros de QA pueden conectar el mismo flujo a las tuberías de prueba de API existentes.

Técnicas avanzadas y consejos profesionales

La cuantificación es la palanca que decide si un modelo de 70B cabe en su portátil. El formato GGUF almacena pesos en 8, 6, 5, 4, 3 o 2 bits por parámetro. Q4_K_M es el predeterminado por una razón. Pierde 0.6 puntos porcentuales en el benchmark MMLU en comparación con FP16 y reduce un modelo de 70B de 140 GB a 40 GB. Q8 lo mantiene dentro de 0.1 puntos de FP16 pero duplica la huella de disco y RAM. Q2_K ahorra espacio pero el impacto en la perplejidad es visible en cualquier tarea con contexto largo. Elija Q4_K_M para el chat, Q8 para la generación de código y Q5_K_M cuando tenga la RAM y quiera un margen de seguridad.

La descarga a la GPU (GPU offload) mediante la bandera -ngl en llama.cpp o la opción num_gpu en Ollama controla cuántas capas del transformador residen en la GPU. Configúrelo tan alto como su VRAM lo permita. Cada capa que vuelve a la CPU reduce el rendimiento en aproximadamente un 30 por ciento. En una tarjeta de 24 GB, un modelo Q4 de 70B puede alojar 40 de 80 capas. En 48 GB puede alojar toda la pila.

El mapeo de memoria (mmap) está activado por defecto en llama.cpp y Ollama. Permite que el sistema operativo pagine los pesos bajo demanda en lugar de asignar el modelo completo al inicio. Manténgalo activado a menos que se esté ejecutando en un contenedor con límites de memoria estrictos. Con mmap desactivado, la latencia del primer token disminuye en aproximadamente 200 ms, pero el uso de RAM se duplica.

El procesamiento por lotes es el superpoder de vLLM. Envíe 32 solicitudes concurrentes y vLLM las agrupa en un solo paso de GPU. El rendimiento escala casi linealmente hasta el límite de cálculo de la GPU. Establezca --max-num-seqs 64 para portátiles con memoria CPU compartida y --max-num-seqs 256 para hardware de clase H100.

Las respuestas por streaming reducen la latencia percibida a la mitad. Establezca stream=True en el SDK de OpenAI y el servidor vaciará los tokens a medida que se generan. El primer byte llega en 200 a 500 ms en lugar de esperar la finalización completa. Cada tiempo de ejecución en esta guía lo admite.

El Modelfile de Ollama le permite integrar un prompt del sistema, la temperatura y las secuencias de parada en un modelo nombrado para que el código de su aplicación se mantenga limpio. Ejecute ollama create my-assistant -f Modelfile una vez y su cliente apuntará a my-assistant en lugar de repetir el prompt del sistema en cada solicitud.

Errores comunes

Codificar http://localhost:11434 en el código de producción. Use una variable de entorno.
Olvidar que los modelos locales no imponen max_tokens. Generarán alegremente 4,096 tokens de sobra. Establezca una secuencia de parada.
Ejecutar Ollama y otro tiempo de ejecución en el mismo puerto. Ambos usan puertos limpios por defecto, pero los puertos personalizados chocan silenciosamente.
Omitir el encabezado Authorization. Ollama lo ignora, pero vLLM con --api-key rechazará las solicitudes no autenticadas con un 401.
Cargar un modelo Q4 y esperar la calidad de GPT-5.5 en matemáticas. La cuantificación erosiona el razonamiento más rápido.

Local vs. alojado: cálculo de costos y latencia

Los números a continuación asumen un M3 Max con 128 GB de memoria unificada para lo local y los precios públicos actuales para los endpoints alojados. El tiempo hasta el primer token (TTFP) se mide en frío, sin procesamiento por lotes, con un prompt de 1,024 tokens.

Modelo	TTFP local	Rendimiento local	Equivalente alojado	Precio alojado	TTFP alojado
Llama 3.3 70B Q4_K_M	1.2 s	12 tok/s	GPT-5.5 Instant	$5 / $30 por 1M	200 ms
DeepSeek V4 67B Q4_K_M	1.4 s	10 tok/s	DeepSeek-Chat alojado	$0.55 / $2.20 por 1M	280 ms
Qwen 3.6 32B Q5_K_M	0.7 s	28 tok/s	Qwen-Max alojado	$1.60 / $6.40 por 1M	240 ms
Gemma 4 27B Q4_K_M	0.5 s	35 tok/s	Gemini 3 Flash	$0.35 / $1.05 por 1M	180 ms

La columna de modelos alojados gana en latencia en cada ocasión. La columna de modelos locales gana en costo en el momento en que se superan aproximadamente 10 millones de tokens al día, y gana en privacidad desde la primera solicitud. Para el desarrollo, casi siempre querrá un modelo local. Para la producción orientada al usuario, casi siempre querrá uno alojado, a menos que la clasificación de sus datos lo prohíba.

Un patrón práctico: ejecute localmente durante el ciclo de desarrollo interno, cambie a alojado en staging, mantenga ambos objetivos en verde en CI. Las pruebas de escenario de Apidog de la sección anterior admiten ese patrón con un solo interruptor de entorno. Para puntos de referencia más profundos en modelos individuales, consulte Cómo ejecutar DeepSeek V4 localmente y la guía de uso original de DeepSeek V4.

Casos de uso reales

Un equipo de cumplimiento financiero en Singapur utiliza Ollama en los portátiles de los ingenieros para redactar informes de actividades sospechosas. Los prompts contienen números de cuenta y patrones de transacciones que no pueden salir del país según las normas de la MAS. El endpoint alojado que utilizan en producción recibe una versión redactada del mismo prompt. Los escenarios de Apidog aseguran que el redactor se ejecute en cada solicitud antes de que salga de localhost.

Un estudio de juegos en Estocolmo capacita a los pasantes de diseño en ingeniería de prompts con una instancia local de Qwen 3.6. Gratuito, sin conexión y con imposibilidad de filtrar la historia del próximo juego a un tercero. El mismo proyecto se distribuye con Gemini 3 Flash en producción con un solo cambio de variable de entorno. Reutilizan la guía de la API de Gemini 3 Flash para la conexión a producción.

Una startup de atención médica ejecuta vLLM en un A100 arrendado dentro de la red del hospital del cliente. El endpoint nunca ve un DNS público. Sus pruebas de integración se ejecutan desde un agente de Jenkins en la misma VLAN contra el mismo SDK de OpenAI que usan localmente. Mismo código, tres destinos de implementación, una suite de escenarios.

Conclusión

La pila de API LLM locales maduró rápidamente. Puede mover sus prompts de un endpoint alojado sin reescribir su cliente, sus pruebas o su CI. Los cinco pasos que hacen esto realidad:

Elija Ollama para portátiles, vLLM para clústeres de desarrollo compartidos, llama.cpp para presupuestos de memoria ajustados.
Exponga el endpoint compatible con OpenAI y verifique con un curl de una línea.
Mueva base_url y api_key a variables de entorno para que el mismo código acceda a lo local y a lo alojado.
Cree pruebas de escenario en Apidog que se ejecuten de manera idéntica en ambos entornos.
Observe la tabla de costo vs. latencia y elija el objetivo correcto para cada carga de trabajo.

La señal de HN que impulsó "La IA local debe ser la norma" a más de 1,700 puntos es consecuencia de esta madurez. Una vez que la superficie de la API se estabilizó, cada herramienta de desarrollo se adaptó a ella. Descargue Apidog y apunte un entorno a http://localhost:11434/v1 para ver lo rápido que se cierra el ciclo. Si aún no ha elegido un modelo, comience con Los mejores LLM locales de 2026, y si desea una inmersión más profunda en la prueba de flujos de agentes sobre cualquiera de estos endpoints, lea Cómo probar la API de agentes de IA.

button