API Compatible con OpenAI de Ollama: Integra Tu Modelo Ajustado en Cualquier Integración OpenAI

Ollama expone una API REST compatible con OpenAI en http://localhost:11434/v1. Esto significa que cada biblioteca, framework y aplicación que se integra con OpenAI puede apuntar a tu modelo local ajustado con un cambio de una sola línea.

Sin nuevos SDKs. Sin código wrapper de API. Solo cambia el baseURL y el nombre del modelo.

Qué Significa Realmente "Compatible con OpenAI"

Ollama implementa el formato de API de Chat Completions de OpenAI:

• POST /v1/chat/completions — el endpoint principal
• Formato de cuerpo de solicitud idéntico al de OpenAI (model, messages, temperature, max_tokens, stream, etc.)
• Formato de respuesta idéntico (choices, message.content, usage, etc.)

No todas las funciones de OpenAI están implementadas. Soportadas:

• Chat completions (lo más importante)
• Streaming vía stream: true
• Embeddings vía POST /v1/embeddings (modelos selectos)
• Listado de modelos vía GET /v1/models

No soportado:

• Fine-tuning vía API (esto lo haces en Ertas)
• Generación de imágenes
• APIs de voz/audio
• API de Asistentes (la interfaz stateful de threads/runs)
• Funciones específicas de OpenAI como moderación o modo JSON con esquema estricto

Para inferencia (la gran mayoría de casos de uso), la compatibilidad es completa.

La Migración de Una Línea

JavaScript / Node.js:

// Antes (OpenAI en la nube)
import OpenAI from 'openai';
const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY
});

// Después (modelo local con Ollama) — un solo cambio
import OpenAI from 'openai';
const client = new OpenAI({
  baseURL: 'http://localhost:11434/v1',
  apiKey: 'ollama' // Campo requerido pero no validado por Ollama
});

// Tu código de generación NO CAMBIA
const response = await client.chat.completions.create({
  model: 'your-fine-tuned-model', // Esto cambia al nombre de tu modelo en Ollama
  messages: [
    { role: 'user', content: 'Your prompt here' }
  ]
});

console.log(response.choices[0].message.content);

Python:

# Antes
from openai import OpenAI
client = OpenAI(api_key="sk-...")

# Después — un solo cambio
from openai import OpenAI
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # No validado
)

# Mismo código de generación
response = client.chat.completions.create(
    model="your-fine-tuned-model",
    messages=[{"role": "user", "content": "Your prompt"}]
)
print(response.choices[0].message.content)

Curl:

# Antes
curl https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gpt-4o", "messages": [{"role": "user", "content": "Hello"}]}'

# Después — cambia URL y modelo
curl http://localhost:11434/v1/chat/completions \
  -H "Authorization: Bearer ollama" \
  -H "Content-Type: application/json" \
  -d '{"model": "your-fine-tuned-model", "messages": [{"role": "user", "content": "Hello"}]}'

Frameworks y Bibliotecas que Funcionan Inmediatamente

Como Ollama es compatible con OpenAI, todos estos funcionan con cero cambios de código más allá del baseURL:

La mayoría de herramientas que soportan "OpenAI con base URL personalizada" funcionan. La mayoría de herramientas que tienen URLs de OpenAI codificadas directamente no funcionan.

Servidor Ollama Remoto

Cuando tu Ollama se ejecuta en un VPS (no en localhost), necesitas exponerlo:

En el VPS:

# Ollama escucha en 0.0.0.0 por defecto cuando OLLAMA_HOST está configurado
OLLAMA_HOST=0.0.0.0:11434 ollama serve

Nota de seguridad: Nunca expongas el puerto de Ollama directamente a internet. Coloca Nginx al frente con autenticación básica o validación de API key:

server {
    listen 443 ssl;
    server_name ollama.yourdomain.com;

    location /v1/ {
        # Verificación simple de API key
        if ($http_authorization != "Bearer your-secret-key") {
            return 401 '{"error": "Unauthorized"}';
        }
        proxy_pass http://localhost:11434/v1/;
    }
}

Luego en tu código:

const client = new OpenAI({
  baseURL: 'https://ollama.yourdomain.com/v1',
  apiKey: 'your-secret-key'
});

Esto te da una API de modelo ajustado completamente segura, accesible remotamente y compatible con OpenAI. Despliega tu servidor Ollama una vez, úsalo desde cualquier cliente.

Respuestas en Streaming

El streaming funciona de manera idéntica a OpenAI:

const stream = await client.chat.completions.create({
  model: 'your-fine-tuned-model',
  messages: [{ role: 'user', content: 'Generate a long document...' }],
  stream: true
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? '');
}

Para aplicaciones de UI (Next.js con Vercel AI SDK, React con streaming):

// Vercel AI SDK + Ollama
import { createOpenAI } from '@ai-sdk/openai';
import { streamText } from 'ai';

const ollama = createOpenAI({
  baseURL: 'http://localhost:11434/v1',
  apiKey: 'ollama',
});

// En tu ruta de API
const result = streamText({
  model: ollama('your-fine-tuned-model'),
  messages: [...],
});

return result.toDataStreamResponse();

El formato de streaming es idéntico al de OpenAI, así que tus componentes de UI de streaming existentes funcionan sin cambios.

---

Lecturas Adicionales

• Claude Desktop Local Model Setup — Usando Ollama con Claude Desktop vía MCP
• MCP Server Zero API Costs — El caso de costos para inferencia local
• LangChain + Fine-Tuned Local Model — Integración con LangChain en profundidad
• Bootstrap AI SaaS Without API Costs — La economía unitaria de modelos locales