Guía rápida de comandos de Ollama CLI: ls, serve, run, ps + comandos (actualización de 2026)

Este cheatsheet de CLI de Ollama se centra en los comandos que usas cada día (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 sobre “tornillos de rendimiento” para ayudarte a descubrir (y luego profundizar) OLLAMA_NUM_PARALLEL y ajustes relacionados.

Este cheatsheet de Ollama se centra en comandos de CLI, gestión de modelos y personalización, pero también tenemos aquí algunos curl llamadas.

Para una visión completa de dónde se encaja Ollama entre las opciones locales, autohospedadas y en la nube, incluyendo vLLM, Docker Model Runner, LocalAI y proveedores en la nube, consulta Almacenamiento de LLM: Comparación de infraestructura local, autohospedada y en la nube. Si estás comparando diferentes soluciones de almacenamiento local de LLM, consulta nuestra comparación completa de Ollama, vLLM, LocalAI, Jan, LM Studio y más. Para aquellos que buscan alternativas a interfaces de línea de comandos, Docker Model Runner ofrece un enfoque diferente para el despliegue de LLM.

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

• Opción 1: Descargar desde el sitio web
  • Visite ollama.com y descargue el instalador para su sistema operativo (Mac, Linux o Windows).
• Opción 2: Instalar desde la línea de comandos
  • Para usuarios de Mac y Linux, use el siguiente comando:

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

• Siga las instrucciones en pantalla y escriba su contraseña si se le solicita.

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

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

Para cargas de trabajo de IA serias, podría querer comparar opciones de hardware. Hemos benchmarkado NVIDIA DGX Spark vs Mac Studio vs RTX-4080 rendimiento con Ollama, y si está considerando invertir en hardware de alta gama, nuestro comparación de precios y capacidades de DGX Spark proporciona un análisis detallado de costos.

Comandos básicos de CLI de Ollama

Enlaces de salto: Comando ollama serve · Comando ollama launch (integraciones de asistentes de codificación de IA) · Comando ollama run · Banderas de ollama run · Comando ollama ps · Comando ollama show · Ollama signin · Comandos básicos de CLI de Ollama · Tornillos de rendimiento (OLLAMA_NUM_PARALLEL) · Análisis profundo de solicitudes paralelas

CLI de Ollama (qué es)

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

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

Gestión de modelos de Ollama: comandos pull y list

Listar modelos:

ollama list

lo mismo que:

ollama ls

Este comando lista todos los modelos que han sido descargados a su sistema, con sus tamaños de archivo en su HDD/SSD, como

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

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) a su sistema. Los archivos del modelo pueden ser bastante grandes, así que mantenga un ojo en el espacio utilizado por los modelos en el disco duro, o SSD. Incluso podría querer mover todos los modelos de Ollama de su 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. Debes 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 a través de 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 volver a descargar nada. Esto es útil antes de editar un archivo Modelfile — copia primero, personaliza la copia y mantiene 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 incrustación, cuantización, etc.). Hay tres banderas útiles:

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

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

# Detalles a nivel de tensor (útil al depurar la cuantización)
ollama show llama3.2 --verbose

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

Comando ollama serve

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

ollama serve

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

# establecer variables de entorno, luego iniciar el servidor
# hacer que ollama esté 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 una sesión interactiva REPL para la interacción. ¿Quieres entender cómo Ollama gestiona múltiples solicitudes concurrentes? Aprende más sobre cómo Ollama maneja 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
>>> Enviar un mensaje (/? para ayuda)

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

>>> ¿Quién eres?
Pensando...
El usuario pregunta "¿Quién eres?" Pregunta simple. Deberías responder como ChatGPT, un modelo de lenguaje AI, entrenado por OpenAI, 
etc. Proporciona una breve introducción. Probablemente pregunte si necesitas ayuda.
...hecho pensando.

Soy ChatGPT, un modelo de lenguaje AI creado por OpenAI. He sido entrenado en una amplia gama de texto así que puedo ayudar 
a responder preguntas, generar ideas, explicar conceptos, redactar escritura, resolver problemas y mucho más. Piensa 
en mí como un asistente virtual versátil—aquí para proporcionar información, apoyo y conversación cuando lo necesites. ¿Cómo puedo ayudarte hoy?

>>> Enviar 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 pregunta única en un modo no interactivo:

printf "Dame 10 líneas de bash para análisis de logs.\n" | ollama run llama3.2

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

$ ollama run gpt-oss:20b --verbose
>>> ¿Quién eres?
Pensando...
Necesitamos responder a una pregunta simple: "¿Quién eres?" El usuario está preguntando "¿Quién eres?" 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. Mantendremos amistoso.
...hecho pensando.

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

total duration:       1.118585707s
load duration:        106.690543ms
prompt eval count:    71 token(s)
prompt eval duration: 30.507392ms
prompt eval rate:     2327.30 tokens/s
eval count:           132 token(s)
eval duration:        945.801569ms
eval rate:            139.56 tokens/s
>>> /bye
$ 

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

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

Banderas del comando ollama run (referencia completa)

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

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

# Aumentar el tamaño de 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 multilinea sin enviarlo temprano:

>>> """Resumir esto en una frase:
... El rápido zorro 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), pase la ruta de la imagen directamente en el prompt:

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

Generar incrustaciones mediante CLI

Los modelos de incrustación devuelven una matriz JSON en lugar de texto. Canaliza el texto directamente para incrustaciones rápidas de un solo uso:

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

Para cargas de trabajo de incrustación en producción, use el endpoint REST /api/embeddings o el cliente de Python en su lugar.

Forzar salida en formato JSON (–format)

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

Se le instruye al modelo para devolver JSON válido. Útil cuando se canaliza la salida a jq o a un script que espera datos estructurados.

Comando ollama stop

Este comando detiene el modelo especificado que está en ejecución.

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

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

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

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

NAME           ID              SIZE     PROCESSOR    CONTEXT    UNTIL
gpt-oss:20b    17052f91a42e    14 GB    100% GPU     4096       4 minutos desde ahora

Aquí ves en mi PC que el gpt-oss:20b se ajusta muy bien a mi GPU de 16 GB de VRAM y ocupa solo 14 GB.

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

NAME            ID              SIZE     PROCESSOR          CONTEXT    UNTIL
gpt-oss:120b    a951a23b46a1    66 GB    78%/22% CPU/GPU    4096       4 minutos desde ahora

Comando ollama launch (integraciones de asistentes de codificación de IA)

ollama launch es un comando introducido en Ollama v0.15 (enero de 2026) que te da un configuración sin configuración, una línea de configuración para asistentes de codificación de IA populares que se ejecutan 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 endpoint 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 agente sin pagar por llamadas de API o enviar código a la nube, ollama launch es la forma más rápida de hacerlo.

Integraciones compatibles

Uso básico

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

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

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

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

Modelos recomendados

Los agentes de codificación necesitan una gran ventana de contexto para contener el contexto completo de archivos y la historia de conversaciones multivuelta. Ollama recomienda modelos con al menos 64 000 tokens de contexto:

Si tu GPU no puede contener 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. Lanza Claude Code contra él
ollama launch claude --model qwen3-coder

Ollama establece las variables de entorno necesarias y comienza a ejecutar 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.

Tornillos de rendimiento (OLLAMA_NUM_PARALLEL)

Si ves colas o tiempos de espera bajo carga, el primer tornillo 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 throughput, pero puede aumentar la presión de VRAM y 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 solicitudes paralelas

Liberar modelo de Ollama de VRAM (keep_alive)

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

• Liberar modelo de VRAM usando curl:

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

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

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

• Liberar modelo de VRAM usando Python:

import requests

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

Esto es especialmente útil cuando:

• Necesitas liberar memoria de la 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 la memoria después de la última solicitud. Establecerlo en 0 descarga inmediatamente el modelo de VRAM.

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 respondas en inglés plano 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 en el archivo".

Inicio de sesión y cierre de sesión en Ollama (autenticación en el registro)

ollama signin
ollama signout

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

Lo que desbloquea el inicio de sesión:

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

Alternativa: autenticación con clave API

Si estás ejecutando Ollama en una tubería de CI o en un servidor sin cabeza donde el inicio de sesión interactivo de ollama no es práctico, crea una clave API en tus ajustes de cuenta de Ollama y expórtala como una variable de entorno:

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

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

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

• Resumir texto de un archivo:

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

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

• Grabar respuestas del modelo a 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 del CLI de Ollama (generación de texto, análisis)

• Generación de texto:

  • Resumir un archivo de texto grande:

    ollama run llama3.2 "Resuma 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
    

  • Contestar preguntas específicas:

    ollama run llama3.2 "¿Cuáles son las últimas tendencias en IA y cómo afectarán 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 del cliente: 'El producto es fantástico, pero la entrega fue lenta.'"
    

  • Categorizar texto en categorías predefinidas: Use comandos similares para clasificar o categorizar texto según criterios predefinidos.

Usando Ollama con Python (cliente y API)

• Instalar la biblioteca de 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 especificado.

Para integraciones avanzadas de Python, explore usar la API de búsqueda web de Ollama en Python, que cubre capacidades de búsqueda web, llamadas de herramientas y integración con servidores MCP. Si estás construyendo aplicaciones con IA, nuestra comparación de asistentes de codificación de IA puede ayudarte a elegir las herramientas adecuadas para el desarrollo.

Buscas una interfaz basada en web? Abrir WebUI proporciona una interfaz autohospedada con capacidades de RAG y soporte multiusuario. Para despliegues de producción de alto rendimiento, considere vLLM como alternativa. Para comparar Ollama con otras opciones de infraestructura local y en la nube de LLM, vea Almacenamiento de LLM: Comparación de infraestructura local, autohospedada y en la nube.

Enlaces útiles

Configuración y Gestión

• Mover modelos de Ollama a otro disco o carpeta

Alternativas y Comparaciones

• Almacenamiento local de LLM: Guía completa de 2026 - Ollama, vLLM, LocalAI, Jan, LM Studio y más
• Quickstart de vLLM: Servicio de LLM de alto rendimiento
• Docker Model Runner vs Ollama: ¿Cuál elegir?
• Primeras señales de enshittificación de Ollama

Rendimiento y Hardware

• Cómo Ollama maneja solicitudes paralelas
• Cómo Ollama utiliza el rendimiento y los núcleos eficientes de la CPU de Intel
• Comparación de rendimiento de Ollama: NVIDIA DGX Spark vs Mac Studio vs RTX-4080
• DGX Spark vs. Mac Studio: Una mirada práctica y verificada de precios a la supercomputadora 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 de IA
• Open WebUI: Interfaz web autohospedada para LLM
• Interfaz de chat de código abierto para LLM en instancias locales de Ollama
• Restringir LLMs con salida estructurada: Ollama, Qwen3 y Python o Go
• Integrar Ollama con Python: Ejemplos de API REST y cliente de Python
• SDKs de Go para Ollama - comparación con ejemplos