Hoja de trucos de la CLI de Ollama: ls, serve, run, ps y otros comandos (actualización 2026)

Este cheat sheet de la CLI de Ollama se centra en los comandos que utilizas a diario (ollama ls, ollama serve, ollama run, ollama ps, gestión de modelos y flujos de trabajo comunes), con ejemplos que puedes copiar y pegar.

También incluye una breve sección de “ajustes de rendimiento” para ayudarte a descubrir (y luego profundizar) en OLLAMA_NUM_PARALLEL y configuraciones relacionadas.

Este cheat sheet de Ollama se enfoca en comandos de CLI, gestión de modelos y personalización, Pero también tenemos aquí algunas llamadas a curl.

Para una visión completa de dónde encaja Ollama entre las opciones locales, autoalojadas y en la nube, incluyendo vLLM, Docker Model Runner, LocalAI y proveedores en la nube, consulta Alojamiento de LLM: Infraestructura Local, Autoalojada y en la Nube Comparada. Si estás comparando diferentes soluciones de alojamiento de LLM locales, echa un vistazo a nuestra comparación exhaustiva de Ollama, vLLM, LocalAI, Jan, LM Studio y más. Para aquellos que buscan alternativas a las interfaces de línea de comandos, Docker Model Runner ofrece un enfoque diferente para el despliegue de LLM. Si el tráfico concurrente o la puesta en cola comienzan a presionar a una sola instancia de Ollama, De Ollama a vLLM: Cuándo migrar tu servidor local de LLM describe las señales de migración y un plan de despliegue escalonado.

Instalación de Ollama (descarga e instalación de CLI)

• Opción 1: Descargar desde el sitio web
  • Visita ollama.com y descarga el instalador para tu sistema operativo (Mac, Linux o Windows).
• Opción 2: Instalar mediante línea de comandos
  • Para usuarios de Mac y Linux, usa el comando:

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

• Sigue las instrucciones en pantalla e introduce tu contraseña si se te solicita.

Requisitos del sistema de Ollama (RAM, almacenamiento, CPU)

• Sistema Operativo: Mac, Linux o Windows
• Memoria (RAM): Mínimo 8GB, se recomienda 16GB o más
• Almacenamiento: Al menos ~10GB de espacio libre (los archivos de los modelos pueden ser realmente grandes, lee más aquí Mover modelos de Ollama a otro disco )
• Procesador: Un CPU relativamente moderno (de los últimos 5 años). Si tienes curiosidad sobre cómo Ollama utiliza diferentes arquitecturas de CPU, consulta nuestro análisis de cómo Ollama usa los núcleos de rendimiento y eficientes de Intel.

Para cargas de trabajo de IA serias, es posible que desees comparar opciones de hardware. Hemos realizado benchmarks de rendimiento de NVIDIA DGX Spark vs Mac Studio vs RTX-4080 con Ollama, y si estás considerando invertir en hardware de gama alta, nuestra comparación de precios y capacidades de DGX Spark proporciona un análisis detallado de costos.

Comandos básicos de la CLI de Ollama

Enlaces rápidos: Comando Ollama serve · Comando Ollama launch · Comando Ollama run · Banderas de Ollama run · Comando Ollama ps · Comando Ollama show · Ollama signin · Básicos de la CLI de Ollama · Ajustes de rendimiento (OLLAMA_NUM_PARALLEL) · Análisis profundo de solicitudes paralelas

CLI de Ollama (qué es)

Ollama CLI es la interfaz de línea de comandos para gestionar modelos y ejecutarlos/servirlos localmente. La mayoría de los flujos de trabajo se reducen a:

• Iniciar el servidor: ollama serve
• Ejecutar un modelo: ollama run <modelo>
• Ver qué está cargado/en ejecución: ollama ps
• Gestionar modelos: ollama pull, ollama list, ollama rm

Gestión de modelos de Ollama: comandos para descargar y listar modelos

Listar Modelos:

ollama list

lo mismo que:

ollama ls

Este comando lista todos los modelos que se han descargado en tu sistema, con sus tamaños de archivo en tu HDD/SSD, como

$ ollama ls
NAME                                                    ID              SIZE      MODIFIED     
deepseek-r1:8b                                          6995872bfe4c    5.2 GB    2 weeks ago     
gemma3:12b-it-qat                                       5d4fa005e7bb    8.9 GB    2 weeks ago     
LoTUs5494/mistral-small-3.1:24b-instruct-2503-iq4_NL    4e994e0f85a0    13 GB     3 weeks ago     
dengcao/Qwen3-Embedding-8B:Q4_K_M                       d3ca2355027f    4.7 GB    4 weeks ago     
dengcao/Qwen3-Embedding-4B:Q5_K_M                       7e8c9ad6885b    2.9 GB    4 weeks ago     
qwen3:8b                                                500a1f067a9f    5.2 GB    5 weeks ago     
qwen3:14b                                               bdbd181c33f2    9.3 GB    5 weeks ago     
qwen3:30b-a3b                                           0b28110b7a33    18 GB     5 weeks ago     
devstral:24b                                            c4b2fa0c33d7    14 GB     5 weeks ago  

Descargar un Modelo: ollama pull

ollama pull mistral-nemo:12b-instruct-2407-q6_K

Este comando descarga el modelo especificado (por ejemplo, Gemma 2B, o mistral-nemo:12b-instruct-2407-q6_K) en tu sistema. Los archivos del modelo pueden ser bastante grandes, así que mantén un ojo en el espacio utilizado por los modelos en el disco duro o SSD. Incluso podrías querer mover todos los modelos de Ollama desde tu directorio de inicio a otro disco más grande y mejor

Subir un Modelo: ollama push

ollama push my-custom-model

Sube un modelo local al registro de Ollama para que otros puedan descargarlo. Necesitas iniciar sesión primero (ollama signin) y el nombre del modelo debe estar prefijado con tu nombre de usuario de Ollama, por ejemplo, myuser/my-model. Usa --insecure si estás subiendo a un registro privado sobre HTTP:

ollama push myuser/my-model --insecure

Copiar un Modelo: ollama cp

ollama cp llama3.2 my-llama3-variant

Crea una copia local de un modelo bajo un nuevo nombre sin descargar nada de nuevo. Esto es útil antes de editar un Modelfile: copia primero, personaliza la copia y mantén el original intacto:

ollama cp qwen3:14b qwen3-14b-custom
ollama create qwen3-14b-custom -f ./Modelfile

Comando Ollama show

ollama show imprime información sobre un modelo descargado.

ollama show qwen3:14b

Por defecto imprime la tarjeta del modelo (arquitectura, longitud de contexto, longitud de embedding, cuantización, etc.). Hay tres banderas útiles:

# Ver exactamente con qué prompt de sistema y plantilla se construyó un modelo
ollama show deepseek-r1:8b --modelfile

# Verificar el tamaño de la ventana de contexto y otros parámetros de inferencia
ollama show qwen3:14b --parameters

# Detalle completo a nivel de tensor (útil cuando se depura la cuantización)
ollama show llama3.2 --verbose

La salida de --modelfile es especialmente útil antes de personalizar un modelo: puedes copiar el Modelfile base y editarlo desde allí en lugar de escribir uno desde cero.

Comando Ollama serve

ollama serve inicia el servidor local de Ollama (puerto HTTP por defecto 11434).

ollama serve

Comando “ollama serve” (ejemplo compatible con systemd):

# establecer variables de entorno, luego iniciar el servidor
# hacer ollama disponible en la dirección IP del host
export OLLAMA_HOST=0.0.0.0:11434
export OLLAMA_NUM_PARALLEL=2
ollama serve

Comando Ollama run

Ejecutar un Modelo:

ollama run gpt-oss:20b

Este comando inicia el modelo especificado y abre un REPL interactivo para la interacción. ¿Quieres entender cómo Ollama gestiona múltiples solicitudes concurrentes? Aprende más sobre cómo Ollama maneja las solicitudes paralelas en nuestro análisis detallado.

ollama run ejecuta un modelo en una sesión interactiva, así que en el caso de gpt-oss:120b verías algo como

$ ollama run gpt-oss:120b
>>> Envía un mensaje (/? para ayuda)

puedes escribir tus preguntas o comandos y el modelo responderá.

>>> ¿quién eres tú?
Pensando...
El usuario pregunta "¿quién eres tú?". Pregunta simple. Debería responder como ChatGPT, un modelo de lenguaje de IA, entrenado por OpenAI,
etc. Proporcionar una breve introducción. Probablemente preguntar si necesitan ayuda.
...terminé de pensar.

Soy ChatGPT, un modelo de lenguaje de IA creado por OpenAI. He sido entrenado con una amplia gama de textos para poder ayudar a
responder preguntas, brainstormear ideas, explicar conceptos, redactar escritos, solucionar problemas y mucho más. Piensa
en mí como un asistente virtual versátil, aquí para proporcionar información, soporte y conversación cuando lo necesites.
¿En qué puedo ayudarte hoy?

>>> Envía un mensaje (/? para ayuda)

Para salir de la sesión interactiva de ollama, presiona Ctrl+D, o puedes escribir /bye, el mismo resultado:

>>> /bye
$ 

Ejemplos del comando Ollama run

Para ejecutar un modelo y hacer una sola pregunta en un modo no interactivo:

printf "Dame 10 one-liners de bash para análisis de logs.\n" | ollama run llama3.2

Si quieres ver una respuesta LLM detallada y verbosa en la sesión de ollama, ejecuta el modelo con el parámetro --verbose o -v:

$ ollama run gpt-oss:20b --verbose
>>> ¿quién eres tú?
Pensando...
Necesitamos responder a una pregunta simple: "¿quién eres tú?". El usuario está preguntando "¿quién eres tú?". Podemos responder que
somos ChatGPT, un modelo de lenguaje grande entrenado por OpenAI. También podemos mencionar capacidades. El usuario probablemente espera
una breve introducción. Lo mantendremos amigable.
...terminé de pensar.

Soy ChatGPT, un modelo de lenguaje grande creado por OpenAI. Estoy aquí para ayudar a responder preguntas, ofrecer explicaciones,
brainstormear ideas y charlar sobre una amplia gama de temas, desde ciencia e historia hasta escritura creativa
y consejos cotidianos. ¡Solo dime de qué te gustaría hablar!

duración total:       1.118585707s
duración de carga:    106.690543ms
conteo de evaluación de prompt: 71 token(s)
duración de evaluación de prompt: 30.507392ms
tasa de evaluación de prompt:     2327.30 tokens/s
conteo de evaluación:           132 token(s)
duración de evaluación:        945.801569ms
tasa de evaluación:            139.56 tokens/s
>>> /bye
$ 

Sí, es correcto, son 139 tokens por segundo. El gpt-oss:20b es muy rápido. Si, como yo, tienes una GPU con 16GB de VRAM, consulta los detalles de la comparación de velocidad de LLMs en Mejores LLMs para Ollama en GPU con 16GB VRAM.

Consejo: Si quieres que el modelo esté disponible sobre HTTP para múltiples aplicaciones, inicia el servidor con ollama serve y usa el cliente de API en lugar de sesiones interactivas largas.

Banderas de Ollama run (referencia completa)

Anular parámetros del modelo sin un Modelfile (-p / –parameters)

La bandera -p te permite cambiar los parámetros de inferencia en tiempo de ejecución sin crear un Modelfile. Puedes apilar múltiples banderas -p:

# Aumentar la ventana de contexto y reducir la temperatura
ollama run qwen3:14b -p num_ctx=32768 -p temperature=0.5

# Ejecutar una tarea de codificación con salida determinista
ollama run devstral:24b -p temperature=0 -p num_ctx=65536

Parámetros comunes que puedes establecer de esta manera:

Entrada multilinea en el REPL

Envuelve el texto en comillas triples (""") para ingresar un prompt de múltiples líneas sin enviarlo prematuramente:

>>> """Resume esto en una frase:
... El rápido perro marrón salta sobre el perro perezoso.
... Sucedió un martes.
... """

Modelos multimodales (imágenes)

Para modelos con capacidad de visión (por ejemplo, gemma3, llava), pasa una ruta de imagen directamente en el prompt:

ollama run gemma3 "¿Qué hay en esta imagen? /home/user/screenshot.png"

Generación de embeddings vía CLI

Los modelos de embedding producen una matriz JSON en lugar de texto. Envía texto directamente para obtener embeddings rápidos de una sola vez:

echo "Hola mundo" | ollama run nomic-embed-text

Para cargas de trabajo de embedding en producción, usa el punto final REST /api/embeddings o el cliente de Python.

Forzar salida JSON (–format)

ollama run llama3.2 --format json "Lista 5 capitales en JSON"

El modelo se instruye para devolver JSON válido. Útil cuando se envía la salida a jq o a un script que espera datos estructurados.

Comando Ollama stop

Este comando detiene el modelo especificado que se está ejecutando.

ollama stop llama3.1:8b-instruct-q8_0

Ollama expulsa los modelos automágicamente después de cierto tiempo. Puedes especificar este tiempo, por defecto es de 4 minutos. Si no quieres esperar el tiempo restante, podrías querer usar este comando ollama stop. También puedes sacar el modelo de la VRAM llamando al punto final de API /generate con el parámetro keep_alive=0, ver la descripción y ejemplo a continuación.

Comando Ollama ps

ollama ps muestra los modelos y sesiones actualmente en ejecución (útil para depurar “¿por qué mi VRAM está llena?”).

ollama ps

El ejemplo de la salida de ollama ps es el siguiente:

NOMBRE           ID              TAMAÑO     PROCESADOR    CONTEXTO    HASTA
gpt-oss:20b    17052f91a42e    14 GB    100% GPU     4096       4 minutos desde ahora

Aquí ves en mi PC que el gpt-oss:20b cabe muy bien en los 16GB de VRAM de mi GPU, y ocupó solo 14GB.

Si ejecuto ollama run gpt-oss:120b y luego llamo a ollama ps, el resultado no será tan brillante: El 78% de las capas están en la CPU, y esto es solo con la ventana de contexto de 4096 tokens. Será más si necesito aumentar el contexto.

NOMBRE            ID              TAMAÑO     PROCESADOR          CONTEXTO    HASTA
gpt-oss:120b    a951a23b46a1    66 GB    78%/22% CPU/GPU    4096       4 minutos desde ahora

Comando Ollama launch (integraciones de codificación IA)

ollama launch es un comando introducido en Ollama v0.15 (enero de 2026) que te ofrece una configuración de una sola línea y sin configuración para asistentes de codificación IA populares ejecutándose contra tu servidor local de Ollama.

¿Por qué usar ollama launch?

Antes de ollama launch, conectar un agente de codificación como Claude Code o Codex a un backend local de Ollama significaba configurar manualmente variables de entorno, apuntar la herramienta al punto final de API correcto y elegir un modelo compatible. ollama launch maneja todo eso para ti de forma interactiva.

Si ya ejecutas Ollama localmente y quieres un asistente de codificación agéntico sin pagar por llamadas a la API o enviar código a la nube, ollama launch es el camino más rápido.

Integraciones soportadas

Uso básico

# Selector interactivo — elige una integración de un menú
ollama launch

# Lanzar una integración específica directamente
ollama launch claude

# Lanzar con un modelo específico
ollama launch claude --model qwen3-coder

# Configurar la integración sin lanzarla (útil para inspeccionar configuraciones)
ollama launch droid --config

Modelos recomendados

Los agentes de codificación necesitan una ventana de contexto larga para mantener el contexto de archivos completos e historial de conversaciones de múltiples turnos. Ollama recomienda modelos con al menos 64 000 tokens de contexto:

Si tu GPU no puede cargar el modelo, Ollama también ofrece variantes alojadas en la nube (por ejemplo, qwen3-coder:480b-cloud) que se integran de la misma manera pero enrutan la inferencia a la capa de nube de Ollama — requiriendo ollama signin.

Ejemplo: ejecutar Claude Code localmente con Ollama

# 1. Asegúrate de que el modelo está disponible
ollama pull qwen3-coder

# 2. Lanzar Claude Code contra él
ollama launch claude --model qwen3-coder

Ollama establece las variables de entorno necesarias e inicia Claude Code apuntando a http://localhost:11434 automáticamente. Luego puedes usar Claude Code exactamente como lo harías normalmente — la única diferencia es que la inferencia ocurre en tu propio hardware.

Ajustes de rendimiento (OLLAMA_NUM_PARALLEL)

Si ves puesta en cola o tiempos de espera bajo carga, la primera perilla que debes aprender es OLLAMA_NUM_PARALLEL.

• OLLAMA_NUM_PARALLEL = cuántas solicitudes ejecuta Ollama en paralelo.
• Un valor más alto puede aumentar el rendimiento, pero puede aumentar la presión de VRAM y los picos de latencia.

Ejemplo rápido:

OLLAMA_NUM_PARALLEL=2 ollama serve

Para una explicación completa (incluyendo estrategias de ajuste y modos de fallo), consulta:

• Cómo Ollama maneja las solicitudes paralelas

Liberar el modelo de Ollama de la VRAM (keep_alive)

Cuando un modelo se carga en la VRAM (memoria GPU), se queda allí incluso después de que termines de usarlo. Para liberar explícitamente un modelo de la VRAM y liberar memoria GPU, puedes enviar una solicitud a la API de Ollama con keep_alive: 0.

• Liberar Modelo de la VRAM usando curl:

curl http://localhost:11434/api/generate -d '{"model": "MODELNAME", "keep_alive": 0}'

Reemplaza MODELNAME con tu nombre de modelo real, por ejemplo:

curl http://localhost:11434/api/generate -d '{"model": "qwen3:14b", "keep_alive": 0}'

• Liberar Modelo de la VRAM usando Python:

import requests

response = requests.post(
    'http://localhost:11434/api/generate',
    json={'model': 'qwen3:14b', 'keep_alive': 0}
)

Esto es particularmente útil cuando:

• Necesitas liberar memoria GPU para otras aplicaciones
• Estás ejecutando múltiples modelos y quieres gestionar el uso de VRAM
• Has terminado de usar un modelo grande y quieres liberar recursos inmediatamente

Nota: El parámetro keep_alive controla cuánto tiempo (en segundos) un modelo permanece cargado en memoria después de la última solicitud. Establecerlo en 0 descarga inmediatamente el modelo de la VRAM.

Si prefieres evitar por completo la capa de abstracción de Ollama y quieres control directo sobre qué modelo GGUF está residente en cualquier momento, modo enrutador de llama-server cubre el enfoque nativo de llama.cpp para el cambio dinámico de modelos.

Personalizando modelos de Ollama (prompt de sistema, Modelfile)

• Establecer Prompt de Sistema: Dentro del REPL de Ollama, puedes establecer un prompt de sistema para personalizar el comportamiento del modelo:

  >>> /set system Para todas las preguntas respondidas, responde en inglés claro evitando el jerga técnica tanto como sea posible
  >>> /save ipe
  >>> /bye
  

  Luego, ejecuta el modelo personalizado:

  ollama run ipe
  

  Esto establece un prompt de sistema y guarda el modelo para uso futuro.

• Crear Archivo de Modelo Personalizado: Crea un archivo de texto (por ejemplo, custom_model.txt) con la siguiente estructura:

  FROM llama3.1
  SYSTEM [Tus instrucciones personalizadas aquí]
  

  Luego, ejecuta:

  ollama create mymodel -f custom_model.txt
  ollama run mymodel
  

  Esto crea un modelo personalizado basado en las instrucciones del archivo".

Ollama signin y signout (autenticación del registro)

ollama signin
ollama signout

ollama signin autentica tu instalación local de Ollama con el registro de Ollama en ollama.com. Una vez conectado, el cliente almacena las credenciales localmente y las reutiliza automáticamente para comandos posteriores.

Qué desbloquea signin:

• Descargar y subir modelos privados desde tu cuenta u organización.
• Usar modelos alojados en la nube (por ejemplo, qwen3-coder:480b-cloud) que son demasiado grandes para ejecutar localmente.
• Publicar modelos en el registro con ollama push.

Alternativa: Autenticación con clave de API

Si estás ejecutando Ollama en una pipeline de CI o un servidor sin interfaz gráfica donde ollama signin interactivo no es práctico, crea una clave de API en la configuración de tu cuenta de Ollama y expónla como una variable de entorno:

export OLLAMA_API_KEY=ollama_...
ollama pull myorg/private-model

La variable OLLAMA_API_KEY es recolectada automáticamente por cada comando de Ollama y solicitud de API — no es necesario ejecutar ollama signin en cada máquina.

Usando el comando Ollama run con archivos (resumir, redirigir)

• Resumir Texto desde un Archivo:

  ollama run llama3.2 "Resume el contenido de este archivo en 50 palabras." < input.txt
  

  Este comando resume el contenido de input.txt usando el modelo especificado.

• Registrar Respuestas del Modelo en un Archivo:

  ollama run llama3.2 "Cuéntame sobre la energía renovable." > output.txt
  

  Este comando guarda la respuesta del modelo en output.txt.

Casos de uso de la CLI de Ollama (generación de texto, análisis)

• Generación de Texto:

  • Resumir un archivo de texto grande:

    ollama run llama3.2 "Resume el siguiente texto:" < long-document.txt
    

  • Generar contenido:

    ollama run llama3.2 "Escribe un artículo corto sobre los beneficios de usar IA en la atención médica." > article.txt
    

  • Responder preguntas específicas:

    ollama run llama3.2 "¿Cuáles son las últimas tendencias en IA y cómo afectarán a la atención médica?"
    

  .

• Procesamiento y Análisis de Datos:

  • Clasificar texto en sentimiento positivo, negativo o neutral:

    ollama run llama3.2 "Analiza el sentimiento de esta reseña de cliente: 'El producto es fantástico, pero la entrega fue lenta.'"
    

  • Categorizar texto en categorías predefinidas: Usa comandos similares para clasificar o categorizar texto basado en criterios predefinidos.

Usando Ollama con Python (cliente y API)

• Instalar Biblioteca Python de Ollama:

  pip install ollama
  

• Generar Texto Usando Python:

  import ollama
  
  response = ollama.generate(model='gemma:2b', prompt='¿qué es un qubit?')
  print(response['response'])
  

  Este fragmento de código genera texto usando el modelo y el prompt especificados.

Para una integración avanzada con Python, explora usando la API de Búsqueda Web de Ollama en Python, que cubre capacidades de búsqueda web, llamada de herramientas e integración con servidores MCP. Si estás construyendo aplicaciones impulsadas por IA, nuestra comparación de Asistentes de Codificación IA puede ayudarte a elegir las herramientas correctas para el desarrollo.

¿Buscas una interfaz basada en web? Open WebUI proporciona una interfaz autoalojada con capacidades RAG y soporte multiusuario. Para despliegues de producción de alto rendimiento, considera vLLM como alternativa. Para comparar Ollama con otras opciones de infraestructura de LLM locales y en la nube, consulta Alojamiento de LLM: Infraestructura Local, Autoalojada y en la Nube Comparada.

Enlaces útiles

Configuración y Gestión

• Mover Modelos de Ollama a Otro Disco o Carpeta

Alternativas y Comparaciones

• Alojamiento Local de LLM: Guía Completa 2026 - Ollama, vLLM, LocalAI, Jan, LM Studio & Más
• Inicio Rápido de vLLM: Servicio de LLM de Alto Rendimiento
• Docker Model Runner vs Ollama: ¿Cuál Elegir?
• Primeras Señales de la Degradación de Ollama
• De Ollama a vLLM: Cuándo Migrar tu Servidor Local de LLM

Rendimiento y Hardware

• Cómo Ollama Maneja las Solicitudes Paralelas
• Cómo Ollama Usa los Núcleos de Rendimiento y Eficientes de Intel
• NVIDIA DGX Spark vs Mac Studio vs RTX-4080: Comparación de Rendimiento de Ollama
• DGX Spark vs. Mac Studio: Una Mirada Práctica y Verificada por Precios al Supercomputador de IA Personal de NVIDIA

Integración y Desarrollo

• Usando la API de Búsqueda Web de Ollama en Python
• Comparación de Asistentes de Codificación IA
• Open WebUI: Interfaz de LLM Autoalojada
• Interfaces de Chat de Código Abierto para LLMs en Instancias Locales de Ollama
• Restringir LLMs con Salida Estructurada: Ollama, Qwen3 & Python o Go
• Integrando Ollama con Python: Ejemplos de API REST y Cliente Python
• SDKs de Go para Ollama - comparación con ejemplos