Cómo montar modelos locales con Ollama en tu entorno de desarrollo

Ollama es la herramienta más directa para tener un LLM corriendo en tu máquina sin depender de OpenAI, Anthropic ni ninguna API externa. Descargas el binario, corres un comando y en minutos tienes un modelo local listo para desarrollar, prototipar o integrar en tus herramientas — sin enviar datos a terceros, sin límites de rate y sin costos por token.

Tip Pro: Usar Ollama en desarrollo te ahorra costo de API mientras prototipas. Cuando pasas a producción, cambias el endpoint a un proveedor cloud sin tocar casi nada.

Contexto

Antes de Ollama, correr un LLM local implicaba clonar repositorios de Hugging Face, instalar dependencias de Python, configurar CUDA y escribir código boilerplate solo para hacer un inference. Ollama resuelve todo eso con una interfaz simplificada: descargas el binario, ejecutas ollama pull <modelo> y obtienes una API REST en localhost:11434 lista para usar.

Ollama es un wrapper que empaqueta el runtime del modelo (llama.cpp con una capa de servidor) y expone:

• Una CLI para descargar, ejecutar y gestionar modelos.
• Una API REST compatible con el formato de OpenAI (para que migrar sea trivial).
• Bindings para Python, JavaScript, Go y más lenguajes.
• Soporte para GPUs NVIDIA (CUDA) y AMD (ROCm), además de CPU.

Los modelos que puedes correr van desde los ligeros como Llama 3.2 (1B y 3B) hasta pesos completos de 70B cuantizados, pasando por Mistral, Gemma, Phi, Qwen, DeepSeek y cientos más en la librería oficial de Ollama.

Nota: Ollama no entrena modelos. Solo los ejecuta localmente. El entrenamiento sigue siendo cosa de frameworks como Axolotl o Unsloth.

Configuración / setup

1. Instalación

Linux / macOS:

curl -fsSL https://ollama.com/install.sh | sh

Windows:

Descarga el instalador desde ollama.com/download y ejecútalo.

Advertencia: En Windows, Ollama corre sobre WSL2. Asegúrate de tener WSL2 instalado y configurado antes de instalar.

2. Verificar instalación

ollama --version
# ollama version 0.6.2

3. Descargar un modelo

# Modelo ligero para desarrollo
ollama pull llama3.2:3b
 
# Modelo más capaz (necesita ~8GB de RAM)
ollama pull mistral
 
# Modelo multimodal (texto + imágenes)
ollama pull llava

Cada modelo se descarga una vez y queda cachead en ~/.ollama/models/ listo para ejecutar.

Tip Pro: Empieza con llama3.2:3b o phi4:latest. Son modelos ligeros que corren en casi cualquier máquina moderna sin GPU.

4. Ejecutar el modelo

# Modo interactivo en terminal
ollama run llama3.2:3b
 
>>> ¿Cuál es la capital de Chile?
La capital de Chile es Santiago.

5. Usar la API REST

Ollama expone un servidor en http://localhost:11434 automáticamente cuando corres un modelo. Puedes hacer peticiones HTTP directas:

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2:3b",
  "prompt": "¿Qué es un LLM?",
  "stream": false
}'

6. Compatibilidad con OpenAI SDK

Ollama expone un endpoint compatible con la API de OpenAI, lo que significa que puedes apuntar tu código existente a localhost sin cambiar nada más:

from openai import OpenAI
 
client = OpenAI(
    base_url="http://localhost:11434/v1",  # ← solo cambias esto
    api_key="ollama"  # no importa, pero el SDK lo requiere
)
 
response = client.chat.completions.create(
    model="llama3.2:3b",
    messages=[{"role": "user", "content": "Hola, ¿cómo estás?"}]
)
 
print(response.choices[0].message.content)

Eso es todo. Tu código de producción con OpenAI ahora apunta a tu modelo local.

Advertencia: No todos los modelos locales responden igual que GPT-4. No esperes el mismo nivel de razonamiento, especialmente con modelos de 3B o 7B. Úsalos para desarrollar, prototipar y hacer tests.

Ejemplos

Ejemplo 1: Chat interactivo con streaming

from openai import OpenAI
 
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)
 
stream = client.chat.completions.create(
    model="llama3.2:3b",
    messages=[{"role": "user", "content": "Explícame qué es un transformer en 3 líneas"}],
    stream=True
)
 
for chunk in stream:
    print(chunk.choices[0].delta.content or "", end="")

Ejemplo 2: Integrar Ollama con LangChain

from langchain_ollama import ChatOllama
from langchain_core.messages import HumanMessage
 
llm = ChatOllama(model="llama3.2:3b", temperature=0)
 
response = llm.invoke([
    HumanMessage(content="Dame 3 ideas para un proyecto con IA")
])
 
print(response.content)

Ejemplo 3: Ollama como backend para continuar con function calling

ollama pull llama3.1:8b  # soporta tool calls

from openai import OpenAI
 
client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
 
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtiene el clima de una ubicación",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string"}
                },
                "required": ["location"]
            }
        }
    }
]
 
response = client.chat.completions.create(
    model="llama3.1:8b",
    messages=[{"role": "user", "content": "¿Qué clima hace en Buenos Aires?"}],
    tools=tools
)
 
print(response.choices[0].message.tool_calls)

Nota: No todos los modelos en Ollama soportan tool calls (function calling). Revisa la descripción del modelo en la librería de Ollama para ver si lo incluye.

Ejemplo 4: Usar Ollama con un servidor separado

Puedes ejecutar el servidor de Ollama en una máquina remota o contenedor y conectarte desde tu código:

# En la máquina remota o servidor
ollama serve

# Desde tu máquina local
client = OpenAI(
    base_url="http://192.168.1.100:11434/v1",
    api_key="ollama"
)

Esto te permite tener una "GPU box" en tu red local a la que todos los desarrolladores se conectan.

Particularidades

Limitaciones importantes:

• Velocidad: En CPU, modelos de 7B pueden generar 2-10 tokens/segundo. En GPU decente, 20-50 tokens/s. Lejos de la velocidad de APIs cloud.
• Calidad: Los modelos locales más grandes (70B cuantizados) se acercan a GPT-3.5, pero ningún modelo abierto iguala consistentemente a GPT-4 o Claude 3.5 Opus hoy.
• Tool calling: Es experimental en Ollama y no todos los modelos lo implementan correctamente.

Tip Pro: Si tienes una GPU con al menos 8GB de VRAM, usa modelos cuantizados Q4_K_M: ofrecen el mejor balance entre calidad y rendimiento. En CPU, prioriza modelos de 3B o menos.

Historia y evolución