Key Takeaways
- Ollama expone una API REST en `http://localhost:11434/v1` que replica exactamente la API de OpenAI.
- Usa la biblioteca Python de OpenAI: cambia `api_key="openai"` por `api_key="ollama"` y establece `base_url="http://localhost:11434/v1"`.
- El mismo enfoque en Node.js: SDK de OpenAI apuntando a localhost:11434.
- La API compatible con OpenAI es idéntica en Ollama, vLLM y LM Studio -- no se necesitan cambios de código para cambiar de proveedor.
- A partir de mayo de 2026, el streaming (respuestas token a token) y el function calling funcionan con modelos locales a través de esta API.
⚡ Datos rápidos
API de Ollama: `http://localhost:11434/v1` — replica exactamente `/chat/completions` de OpenAI
API de LM Studio: `http://localhost:1234/v1` — mismo formato, puerto diferente
API de vLLM: `http://localhost:8000/v1` — servicio de calidad de producción
Cambio de código: 2 líneas — `base_url` y `api_key`. El resto del código permanece idéntico.
Soportado: Chat completions, text completions, embeddings, streaming, function calling
Autenticación: Ninguna por defecto — solo acceso desde localhost. Añade un reverse proxy para acceso en red.
Modelo para los ejemplos de código: Llama 4 Scout (mejor calidad en 12 GB) o Llama 3.2 3B (ligero)
¿Qué significa compatible con OpenAI?
Compatible con OpenAI significa que el endpoint de la API devuelve respuestas en el mismo formato que la API de OpenAI. Esto permite que cualquier biblioteca o herramienta construida para OpenAI funcione con modelos locales simplemente apuntando a una URL diferente. Consulta cómo Ollama vs LM Studio comparan su implementación de este estándar.
Ejemplo: la biblioteca Python de OpenAI envía peticiones así:
``` POST /chat/completions { "model": "gpt-4o", "messages": [...], "temperature": 0.7 } ```
La API de Ollama acepta exactamente la misma petición en `localhost:11434/v1/chat/completions` y devuelve la respuesta en formato OpenAI:
``` { "choices": [{"message": {"content": "..."}}], "usage": {"prompt_tokens": 10, "completion_tokens": 20} } ```
Como el formato es idéntico, no necesitas aprender una nueva API ni reescribir tu código.
---
🔍 ¿Sabías que: El formato de la API de OpenAI se ha convertido en el estándar no oficial para todas las APIs de LLMs. Anthropic (Claude), Google (Gemini) y todas las principales herramientas de inferencia local (Ollama, vLLM, LM Studio, llama.cpp) ahora lo soportan. El código escrito contra este formato es verdaderamente agnóstico al proveedor — lo más parecido a una API universal que tiene la industria de la IA.
¿Cuál es el endpoint de la API de Ollama?
**Al ejecutar `ollama serve`, Ollama inicia una API REST en `http://localhost:11434`.** Los endpoints compatibles con OpenAI son:
| Endpoint | URL | Descripción |
|---|---|---|
| Chat Completions | POST http://localhost:11434/v1/chat/completions | Equivale a `/chat/completions` de OpenAI |
| Text Completions | POST http://localhost:11434/v1/completions | Equivale a `/completions` de OpenAI |
| Embeddings | POST http://localhost:11434/v1/embeddings | Convierte texto en vectores |
| List Models | GET http://localhost:11434/v1/models | Lista los modelos disponibles |
¿Cómo usar la API de Ollama con Python (biblioteca OpenAI)?
Instala la biblioteca de OpenAI y apúntala a localhost.
🔍 Consejo profesional: Establece `OPENAI_BASE_URL=http://localhost:11434/v1` como variable de entorno. Muchas herramientas (LangChain, LlamaIndex, aider) leen esta variable automáticamente — sin cambios de código. Puedes cambiar entre OpenAI y Ollama modificando solo una variable de entorno.
# 1. Install the OpenAI library
pip install openai
# 2. Connect to Ollama
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:11434/v1",
api_key="ollama" # dummy key; Ollama ignores it
)
# 3. Make a request
response = client.chat.completions.create(
model="llama4:scout", # Best quality on 12 GB VRAM (MoE)
# model="llama3.2:3b", # Lightweight alternative for 8 GB RAM
messages=[
{"role": "user", "content": "What is 2+2?"}
]
)
print(response.choices[0].message.content)¿Cómo usar la API de Ollama con Node.js?
Instala el SDK de OpenAI y conéctalo a tu instancia local de Ollama.
// 1. Install
npm install openai
// 2. Connect to Ollama
const OpenAI = require("openai").default;
const client = new OpenAI({
baseURL: "http://localhost:11434/v1",
apiKey: "ollama"
});
// 3. Make a request
const response = await client.chat.completions.create({
model: "llama4:scout", // Best quality on 12 GB VRAM
// model: "llama3.2:3b", // Lightweight for 8 GB RAM
messages: [{
role: "user",
content: "What is 2+2?"
}]
});
console.log(response.choices[0].message.content);Cómo usar el servidor compatible con OpenAI de LM Studio (localhost:1234)
**LM Studio expone una API compatible con OpenAI en `http://localhost:1234/v1`.** Actívala en la pestaña Local Server -- carga un modelo y haz clic en Start Server. El mismo código Python y Node.js funciona con LM Studio -- solo cambia el puerto de 11434 a 1234.
LM Studio es adecuado para usuarios de interfaz gráfica que quieren explorar modelos visualmente y cambiar entre ellos fácilmente. Ollama es preferible para scripts, automatización y pipelines de CI.
| Plataforma | Puerto | Ideal para | GPU requerida |
|---|---|---|---|
| LM Studio | localhost:1234 | Usuarios GUI, gestión visual de modelos | No (CPU funciona) |
| Ollama | localhost:11434 | Scripts, automatización, producción | No (CPU funciona) |
| vLLM | localhost:8000 | Multi-GPU, servidores de alto rendimiento | Recomendada |
# Python: Connect to LM Studio (localhost:1234)
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:1234/v1",
api_key="lm-studio" # any string; LM Studio ignores it
)
response = client.chat.completions.create(
model="llama-3.2-3b-instruct", # exact model name shown in LM Studio
messages=[
{"role": "user", "content": "What is 2+2?"}
]
)
print(response.choices[0].message.content)¿Cómo usar la API de Ollama desde JavaScript en el navegador?
Llamar a Ollama desde JavaScript del lado del navegador requiere que el navegador y el servidor estén en la misma máquina (o que CORS esté permitido). Por seguridad, las peticiones del navegador a localhost solo funcionan si el JavaScript también se sirve desde localhost. Consulta Los mejores frontends de LLMs locales para UIs listas para el navegador que gestionan esto de forma transparente.
Si necesitas llamar a Ollama desde un navegador en una IP diferente, configura un proxy CORS o usa un middleware del lado del servidor.
// Browser-side JavaScript (if server is localhost:3000, Ollama is localhost:11434)
fetch("http://localhost:11434/v1/chat/completions", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
model: "llama4:scout", // Best quality on 12 GB VRAM
// model: "llama3.2:3b", // Lightweight for 8 GB RAM
messages: [{ role: "user", content: "What is 2+2?" }]
})
})
.then(res => res.json())
.then(data => console.log(data.choices[0].message.content))¿Cómo hacer streaming de respuestas token a token?
El streaming te permite mostrar las respuestas a medida que se generan, token a token, en lugar de esperar a la respuesta completa. A partir de mayo de 2026, el streaming funciona con todos los modelos locales a través de la API compatible con OpenAI.
# Python: streaming example
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:11434/v1",
api_key="ollama"
)
stream = client.chat.completions.create(
model="llama4:scout",
messages=[{"role": "user", "content": "Count to 10"}],
stream=True
)
for chunk in stream:
if chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
¿Tu modelo local puede llamar funciones?
Sí, a partir de mayo de 2026, el function calling funciona con modelos locales a través de la API de OpenAI. Defines un esquema de función y el modelo puede responder con argumentos para pasarle a tu función. Esto permite que los mejores LLMs locales para programación se integren con tu ecosistema de herramientas.
El soporte de function calling depende del modelo. Llama 4 Scout, Qwen3 8B, Gemma 4 9B y Mistral Small 3.1 soportan tool calling de forma fiable. Llama 3.1 8B y Qwen2.5 7B también lo soportan (versiones anteriores). Los modelos más pequeños (3B) pueden no producir JSON de tool call estructurado de forma fiable.
En 2026, el Model Context Protocol (MCP) extiende el function calling hacia una capa de conexión de herramientas estandarizada. MCP permite que cualquier cliente (Claude Code, Cursor, apps personalizadas) se conecte a cualquier servidor de herramientas a través de un único protocolo — yendo más allá de las definiciones de herramientas por petición mostradas arriba. Ollama soporta tool calling estilo MCP a través de la API estándar de function calling compatible con OpenAI. Para integraciones de herramientas en producción, MCP se está convirtiendo en el estándar; los ejemplos de function calling aquí siguen siendo la base.
Al usar APIs compatibles con OpenAI localmente, la salida estructurada y el modo JSON funcionan igual que con las APIs en la nube. Para aplicar conformidad de esquemas y control de formato en modelos locales y en la nube, consulta salida estructurada y modo JSON.
Las APIs compatibles con OpenAI aceptan los mismos formatos de prompt que las versiones en la nube — mensajes de sistema, mensajes de usuario y salida estructurada. La biblioteca completa de técnicas de prompt engineering se aplica directamente a las llamadas de API locales.
# Example: local model calls a weather function
tools = [{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get current weather",
"parameters": {
"type": "object",
"properties": {
"location": {"type": "string"}
}
}
}
}]
response = client.chat.completions.create(
model="llama4:scout",
messages=[{"role": "user", "content": "What is the weather in SF?"}],
tools=tools
)
# Check if model returned a function call
if response.choices[0].message.tool_calls:
call = response.choices[0].message.tool_calls[0]
print(f"Call function: {call.function.name} with {call.function.arguments}")
APIs de LLMs locales compatibles con OpenAI por región
UE / RGPD y AI Act: Para los desarrolladores de la UE, ejecutar Ollama localmente garantiza el cumplimiento del artículo 5 del RGPD (minimización de datos) -- toda la inferencia permanece en el dispositivo sin transferencia de datos a APIs en la nube. Ollama se descarga desde GitHub bajo licencia MIT, cumpliendo los requisitos de conformidad de la UE. Las obligaciones de sistemas de alto riesgo del AI Act de la UE aplican desde el 2 de agosto de 2026 (pendiente Digital Omnibus). La inferencia local de API satisface los requisitos de residencia de datos del RGPD por defecto. Para empresas, esto elimina la dependencia del proveedor y garantiza la residencia de datos.
España y América Latina / RGPD y LSSI: En España, la Ley de Servicios de la Sociedad de la Información (LSSI) y el RGPD exigen el tratamiento responsable de datos personales. Ejecutar Ollama localmente cumple estos requisitos: no hay transferencia de datos a servidores externos. En América Latina, países como México (LFPDPPP), Argentina (Ley 25.326) y Brasil (LGPD) exigen la protección de datos personales; la inferencia local con Ollama satisface estos requerimientos. Ollama + Qwen3 8B funciona en laptops corporativos estándar (8 GB RAM).
China / CAC: Para despliegues bajo la Ley de Ciberseguridad de China (artículo 37 del CAC), la inferencia local satisface los mandatos de localización de datos -- Ollama + Qwen3 funciona en cualquier dispositivo Linux sin llamadas a APIs externas. La tokenización nativa en chino de Qwen3 añade un 30-40% de eficiencia respecto a Llama, reduciendo la sobrecarga de inferencia local.
¿Cuáles son los errores comunes con las APIs de LLMs locales compatibles con OpenAI?
- Olvidar que la API key se ignora. Ollama requiere `api_key="ollama"` (cualquier cadena funciona) porque no autentica. La autenticación real se basa en que la petición proviene de localhost o de tu red local, no de internet.
- No darse cuenta de que el nombre del modelo importa. Si llamas a `/chat/completions` con `model="gpt-4"` pero solo has descargado `llama3.2:3b` en Ollama, la petición fallará. Usa los nombres exactos de modelo de `ollama list`.
- Asumir que Ollama necesita internet. No lo necesita. La API es completamente local. Pero si tu código Python intenta conectarse primero a los servidores de OpenAI (por defecto), fallará. Establece siempre `base_url` explícitamente.
- Errores CORS desde el navegador. Si llamas a Ollama desde un script del lado del navegador y obtienes un error CORS, significa que el navegador bloqueó la petición por seguridad. Consulta LLMs locales con VS Code y Cursor para soluciones basadas en editores que evitan CORS.
- No establecer stream=True cuando se espera streaming. Si quieres respuestas token a token, debes establecer explícitamente `stream=True` en la petición. Por defecto, espera la respuesta completa.
- Usar `llama3.2:3b` en los ejemplos cuando hay modelos mejores disponibles. Muchos tutoriales usan Llama 3.2 3B porque cabe en 8 GB de RAM. Si tienes 12+ GB de VRAM, cambia a `llama4:scout` — calidad dramáticamente mejor para el mismo código de API. Usa modelos 3B solo para probar la integración con la API, no para cargas de trabajo de producción.
- No establecer `OLLAMA_NUM_PARALLEL` para peticiones concurrentes. Por defecto, Ollama procesa una petición a la vez. Para apps multiusuario o suites de pruebas paralelas, establece `OLLAMA_NUM_PARALLEL=4` (o más) para manejar llamadas de API concurrentes. Sin esto, las peticiones se encolan y la latencia aumenta.
- ---
- ⚠️ Advertencia: La API de Ollama NO tiene autenticación por defecto. Si la expones a tu red (`OLLAMA_HOST=0.0.0.0`), cualquier persona en esa red puede enviar peticiones, cargar modelos y consumir recursos de GPU. Para configuraciones multiusuario o de producción, coloca un reverse proxy (nginx, Caddy) con autenticación delante de Ollama — nunca expongas el puerto 11434 directamente a internet.
Preguntas frecuentes sobre las APIs de LLMs locales
¿Necesito modificar mi código de OpenAI para usar Ollama?
No. Establece `base_url="http://localhost:11434/v1"` y `api_key="ollama"`. Todo lo demás permanece igual. Si tienes código que usa la biblioteca de OpenAI, cambia estas dos líneas y funcionará con tu modelo local.
¿Puedo usar la API desde otro ordenador en mi red?
Sí. Por defecto, Ollama escucha solo en localhost. Para permitir el acceso en red, establece la variable de entorno `OLLAMA_HOST=0.0.0.0:11434` antes de ejecutar Ollama. Luego apunta tu código a `http://<ip-de-la-máquina>:11434/v1`. Ten cuidado con la seguridad -- usa un firewall si es producción.
¿LM Studio tiene una API compatible con OpenAI?
Sí. LM Studio expone una API compatible con OpenAI en `http://localhost:1234/v1`. Actívala en la pestaña Local Server, carga un modelo y haz clic en Start Server. Usa el mismo código Python o Node.js que con Ollama -- solo cambia el puerto (1234 en lugar de 11434).
¿Puedo llamar a varios modelos simultáneamente?
Si los tienes cargados en Ollama, sí. Pero ten en cuenta que ejecutar dos modelos simultáneamente duplica el uso de VRAM. Debes tener suficiente memoria GPU.
¿La API está autenticada?
No. Por defecto, la API de Ollama no tiene autenticación. Cualquiera con acceso a localhost:11434 puede usarla. Para producción con acceso en red, añade autenticación a través de un reverse proxy (nginx con Basic Auth, etc.).
¿Cómo uso el streaming con la API OpenAI de Ollama?
Establece stream=True en tu llamada a la biblioteca de OpenAI. Ollama devuelve server-sent events (SSE) con cada token. En Python: for chunk in client.chat.completions.create(stream=True, ...): print(chunk.choices[0].delta.content).
¿Ollama soporta function calling / uso de herramientas a través de la API?
Sí, para los modelos que lo soportan (Llama 4 Scout, Qwen3 8B, Gemma 4 9B, Mistral Small 3.1). Los modelos anteriores (Llama 3.1 8B, Qwen2.5 7B) también lo soportan. Pasa tools=[] en la llamada de API como lo harías con OpenAI. Ollama analiza las llamadas de herramientas y devuelve JSON estructurado. No todos los modelos lo soportan -- consulta la documentación del modelo.
¿Qué es MCP y cómo se relaciona con la API compatible con OpenAI?
MCP (Model Context Protocol) es un protocolo estandarizado para conectar modelos de IA con herramientas y fuentes de datos externas. Se basa en el function calling — el mismo parámetro `tools=[]` mostrado en los ejemplos — pero añade una arquitectura cliente-servidor estándar para que las herramientas sean descubribles y reutilizables entre aplicaciones. Ollama soporta interacciones de herramientas estilo MCP a través de su endpoint de function calling compatible con OpenAI. Para integraciones simples, los ejemplos de function calling de este artículo son suficientes. Para flujos de trabajo complejos con múltiples herramientas, MCP ofrece un enfoque más estructurado.
¿Cuál es la diferencia entre /api/generate y /v1/chat/completions de Ollama?
/api/generate es el endpoint nativo de un solo turno de Ollama. /v1/chat/completions es el endpoint compatible con OpenAI de múltiples turnos. Usa /v1/chat/completions para todos los proyectos nuevos -- soporta historial de conversación y es compatible con las bibliotecas de OpenAI.
¿Puedo usar vLLM como API compatible con OpenAI?
Sí. vLLM ejecuta un servidor compatible con OpenAI en http://localhost:8000/v1 por defecto. Inícialo con: python -m vllm.entrypoints.openai.api_server --model mistralai/Mistral-7B-v0.1. Usa el mismo código cliente que con Ollama.
¿Cómo uso la API de Ollama con el paquete Node.js openai?
Importa OpenAI desde openai. Establece baseURL: "http://localhost:11434/v1" y apiKey: "ollama" en el constructor. Luego llama a client.chat.completions.create() exactamente como lo harías con la API real de OpenAI -- sin más cambios.
¿Cómo cambio entre Ollama y OpenAI en el mismo código?
Usa una variable de entorno: establece USE_LOCAL=true para Ollama (base_url http://localhost:11434/v1, api_key "ollama") y USE_LOCAL=false para OpenAI. La biblioteca Python de OpenAI acepta base_url como argumento del constructor. Establece USE_LOCAL=false en producción para cambiar a OpenAI sin modificar ningún otro código.
¿Puedo usar la API compatible con OpenAI con LangChain?
Sí. Usa ChatOpenAI con base_url="http://localhost:11434/v1" y api_key="ollama". Esto convierte a Ollama en un reemplazo directo de OpenAI en cualquier pipeline de LangChain -- las cadenas RAG, agentes y herramientas funcionan sin modificación. LangChain también tiene una clase ChatOllama dedicada para características específicas de Ollama.
Fuentes
- Ollama. (2026). "Ollama OpenAI Compatibility." https://github.com/ollama/ollama/blob/main/docs/openai.md -- Documentación oficial para los endpoints REST compatibles con OpenAI de Ollama.
- LM Studio. (2026). "LM Studio Local Server." https://lmstudio.ai/docs/local-server -- Documentación del servidor local compatible con OpenAI de LM Studio en localhost:1234.
- OpenAI. (2024). "OpenAI Python Library." https://github.com/openai/openai-python -- SDK de Python oficial usado para conectarse tanto a OpenAI como a LLMs locales mediante la anulación de base_url.
- vLLM Team. (2024). "vLLM OpenAI-Compatible Server." https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html -- Documentación del servidor API compatible con OpenAI de vLLM (puerto 8000, uso en producción).