Hoja de referencia de la CLI de Ollama: ls, serve, run, ps + comandos (actualización 2026)

Esta hoja de referencia 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 la referencia completa de variables de entorno de ollama serve (OLLAMA_NUM_PARALLEL, OLLAMA_CONTEXT_LENGTH, OLLAMA_KV_CACHE_TYPE y otras), las banderas para modelos de razonamiento (--think, --hidethinking) y las integraciones ampliadas de ollama launch para asistentes de codificación con IA. Los comandos y banderas siguientes se han verificado contra Ollama v0.33.2 (octubre de 2026).

Esta hoja de referencia de Ollama se centra en comandos CLI, gestión de modelos y personalización, pero también incluye algunas llamadas curl.

Para tener 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 de nube), consulta Alojamiento de LLM: Infraestructura local, autoalojada y en la nube comparada. Si estás comparando diferentes soluciones de alojamiento local de LLM, echa un vistazo a nuestra comparación exhaustiva de Ollama, vLLM, LocalAI, Jan, LM Studio y más. Para quienes buscan alternativas a las interfaces de línea de comandos, Docker Model Runner ofrece un enfoque diferente al despliegue de LLM. Si el tráfico concurrente o la cola empieza a sobrecargar una única instancia de Ollama, De Ollama a vLLM: Cuándo migrar tu servidor local de LLM detalla las señales de migración y un plan de despliegue por fases.

Instalación de Ollama (descarga e instalación por 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 recomiendan 16GB o más
• Almacenamiento: Al menos ~10GB de espacio libre (los archivos de los modelos pueden ser muy grandes; consulta la sección de gestión de modelos más abajo para saber cómo reubicarlos)
• Procesador: Una CPU relativamente moderna (de los últimos 5 años). Si te interesa saber cómo Ollama utiliza diferentes arquitecturas de CPU, consulta nuestro análisis sobre cómo Ollama utiliza los núcleos de rendimiento y eficiencia de la CPU de Intel.

Comandos básicos de la CLI de Ollama

Ejecutar simplemente ollama sin argumentos ahora abre el mismo menú interactivos de lanzamiento que ollama launch — eliges una integración y un modelo de una lista.

CLI de Ollama (qué es)

La CLI de Ollama 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
• Lanzar un asistente de codificación con IA: ollama launch

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

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 en:

$ 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 (p. ej., Gemma 2B, o mistral-nemo:12b-instruct-2407-q6_K) a tu sistema. Los archivos del modelo pueden ser bastante grandes, así que mantén un ojo al espacio usado por los modelos en el disco duro o ssd. Es posible que incluso quieras mover todos los modelos de Ollama de tu directorio de inicio a otra unidad más grande y mejor

Subir un Modelo: ollama push

ollama push mi-modelo-personalizado

Sube un modelo local al registro de Ollama para que otros puedan descargarlo. Primero debes iniciar sesión (ollama signin) y el nombre del modelo debe tener como prefijo tu nombre de usuario de Ollama, p. ej. miusuario/mi-modelo. Usa --insecure si estás subiendo a un registro privado mediante HTTP:

ollama push miusuario/mi-modelo --insecure

Copiar un Modelo: ollama cp

ollama cp llama3.2 mi-variante-llama3

Crea una copia local de un modelo con un nuevo nombre sin volver a descargar nada. 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-personalizado
ollama create qwen3-14b-personalizado -f ./Modelfile

Eliminar Modelos: ollama rm

ollama rm qwen3:8b
# las versiones más nuevas aceptan varios modelos en una sola llamada:
ollama rm qwen3:8b qwen3:14b

ollama rm elimina el manifiesto del modelo y cualquier blob que ya no sea referenciado por otros modelos, de modo que las capas base compartidas de los modelos derivados se conservan.

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 inserción, cuantización, etc.). Hay seis banderas útiles:

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

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

# Solo el prompt de sistema de un modelo personalizado
ollama show mimodelo --system

# Comprobar la licencia antes de distribuir un modelo dentro de un producto
ollama show llama3.2 --license

# Detalle completo a nivel de tensor (útil al depurar 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 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 ollama disponible en la dirección IP del host
export OLLAMA_HOST=0.0.0.0:11434
export OLLAMA_NUM_PARALLEL=2
ollama serve

ollama start es un alias de ollama serve, por lo que ambos inician el mismo servidor.

Vincular a 0.0.0.0 expone el servidor a tu red sin autenticación: coloca un proxy inverso con TLS delante, como se describe en Ollama detrás de un proxy inverso con Caddy o Nginx, o accede a través de un túnel privado siguiendo los patrones de acceso remoto a Ollama. Para ejecutar el servidor en un contenedor en su lugar, consulta Ollama en Docker Compose con GPU y almacenamiento persistente de modelos.

Variables de entorno de Ollama serve (referencia completa)

Estas son las variables de entorno que ollama serve lee al inicio (a partir de Ollama v0.33):

Por ejemplo, para aumentar la ventana de contexto predeterminada para cada modelo:

OLLAMA_CONTEXT_LENGTH=32768 ollama serve

Longitud de contexto predeterminada por VRAM

Cuando OLLAMA_CONTEXT_LENGTH no está establecida, el servidor elige un predeterminado por niveles basado en la VRAM total de tu máquina (añadido en Ollama v0.15.5):

Ollama recomienda al menos 64,000 tokens para cargas de trabajo exigentes en contexto — búsqueda web, agentes y herramientas de codificación — y la huella de memoria escala con OLLAMA_NUM_PARALLEL, por lo que una configuración de paralelo alta combinada con un contexto predeterminado grande puede empujar las capas del modelo fuera de la VRAM. El servidor registra el valor elegido como vram-based default context al inicio.

El tipo de caché KV intercambia memoria por velocidad: cuantizar la caché KV a q8_0 reduce aproximadamente a la mitad su huella en VRAM y es adecuado para ejecuciones de contexto largo; nuestra prueba de caché KV en una GPU de 16GB con contexto largo mide el efecto real. OLLAMA_NUM_PARALLEL y OLLAMA_MAX_QUEUE se abordan en detalle en Cómo Ollama maneja las solicitudes paralelas.

Comando Ollama run

Ejecutar un Modelo:

ollama run gpt-oss:20b

Este comando inicia el modelo especificado y abre una REPL interactiva 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?
Pensando...
El usuario pregunta "¿quién eres?" Pregunta simple. Debería responder como ChatGPT, un modelo de lenguaje de IA, entrenado por OpenAI, 
etc. Proporcionar introducción breve. Probablemente preguntar si necesita ayuda.
...terminado de pensar.

Soy ChatGPT, un modelo de lenguaje de IA creado por OpenAI. He sido entrenado en una amplia variedad de texto para poder ayudar a 
responder preguntas, generar ideas, explicar conceptos, redactar textos, solucionar 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. ¿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 única pregunta en modo no interactivo:

printf "Dame 10 one-liners de bash para el 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 el parámetro --verbose o -v:

$ 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. Lo mantendremos amistoso.
...terminado de pensar.

Soy ChatGPT, un modelo de lenguaje grande creado por OpenAI. Estoy aquí para ayudar a responder preguntas, ofrecer explicaciones, 
generar ideas y chatear sobre una amplia gama de temas: desde ciencia e historia hasta escritura creativa y consejos cotidianos. ¡Solo dime sobre 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, 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 LLM en Mejores LLMs para Ollama en GPU de 16GB VRAM.

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

Banderas de Ollama run (referencia completa)

Dos variables de entorno afectan a ollama run mismo: OLLAMA_EDITOR establece el editor abierto por Ctrl+G en la REPL, y OLLAMA_NOHISTORY=1 deshabilita la persistencia del historial de readline.

Modelos de razonamiento: –think y –hidethinking

Los modelos con capacidad de razonamiento (deepseek-r1, qwen3, gpt-oss y otros) piensan por defecto en la CLI, y la pista de razonamiento se imprime antes de la respuesta:

ollama run qwen3:14b --think=false "Responde directamente, sin pista de razonamiento"
ollama run deepseek-r1:8b --hidethinking "¿Es 9.9 mayor que 9.11?"   # piensa, pero imprime solo la respuesta

Los modelos GPT-OSS aceptan niveles en lugar de un booleano — ajustan la longitud de la pista en lugar de activarla o desactivarla:

ollama run gpt-oss:20b --think=low "Borra un titular"

Dentro de la sesión interactiva, alterna el razonamiento con /set think y /set nothink.

Sobrescribir parámetros del modelo sin un Modelfile

Los viejos posts de blog muestran una bandera -p / --parameters en ollama run; ya no existe en las versiones actuales. La forma admitida para cambiar parámetros de inferencia sin editar un Modelfile es la REPL:

$ ollama run qwen3:14b
>>> /set parameter num_ctx 32768
Set parameter 'num_ctx' to '32768'
>>> /save qwen3-14b-32k
>>> /bye

/set parameter se aplica solo a la sesión actual, y /save lo persiste en un nuevo modelo local que puedes ejecutar después con ollama run qwen3-14b-32k. /show parameters lista las configuraciones en la sesión actual. Para todos los modelos en un servidor, OLLAMA_CONTEXT_LENGTH en ollama serve cambia la ventana de contexto predeterminada globalmente.

Parámetros comunes que puedes establecer de esta manera:

ollama show <modelo> informa la longitud de contexto que el modelo puede soportar, mientras que ollama ps muestra el contexto realmente asignado para la instancia cargada — consulta Comando Ollama ps si un prompt largo parece estar siendo truncado silenciosamente.

Entrada multilinea en la REPL

Envuelve el texto en comillas triples (""") para introducir un prompt multilinea sin enviarlo temprano:

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

Para prompts más largos, Ctrl+G abre el prompt actual en un editor de texto completo ($EDITOR, o a lo que apunte OLLAMA_EDITOR) y lo envía cuando guardas y sales — útil para iterar en un prompt largo de estilo de sistema (añadido en Ollama v0.16).

Modelos multimodales (imágenes)

Para modelos con capacidad visual (p. ej. gemma3, llava), pasa una ruta de imagen directamente en el prompt:

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

Generar embeddings vía CLI

Los modelos de embedding producen un array JSON en lugar de texto. Envía texto directamente para embeddings rápidos de un solo uso:

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

Dos banderas de ollama run son específicas para modelos de embedding: --dimensions 512 trunca el vector de salida a 512 dimensiones (útil para modelos con capacidad Matryoshka como nomic-embed cuando quieres vectores más pequeños), y --truncate=false hace que las entradas más largas que el contexto del modelo devuelvan un error en lugar de ser truncadas silenciosamente.

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

Forzar salida JSON (–format)

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

Se instruye al modelo para que devuelva JSON válido. Útil al enviar la salida a jq o a un script que espera datos estructurados.

Comando Ollama stop

Este comando detiene el modelo especificado en ejecución.

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

Ollama expulsa modelos automáticamente después de cierto tiempo. El predeterminado es 5 minutos (OLLAMA_KEEP_ALIVE=5m); versiones anteriores de Ollama usaban 4 minutos. Si no quieres esperar el tiempo restante, usa el comando ollama stop. Al iniciar el modelo también puedes pasar --keepalive a ollama run (p. ej. --keepalive 30s, --keepalive -1 para mantener el modelo cargado para siempre), o llamar al punto final de API /generate con el parámetro keep_alive=0 para sacar el modelo de la VRAM inmediatamente — consulta más abajo 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

El 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 minutes from now

La columna CONTEXT es el contexto realmente asignado para esta instancia cargada. Differs from ollama show <modelo>, which reports the context length the model supports — si un modelo trunca silenciosamente tus prompts largos, ollama ps es el comando que revela el valor real de tiempo de ejecución.

Aquí en mi PC ves que el gpt-oss:20b cabe muy bien en los 16GB de VRAM de mi GPU, y ocupa 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 CPU, y esto es solo con la ventana de contexto de 4096 tokens — la huella de memoria crece más si aumento el contexto.

NAME            ID              SIZE     PROCESSOR          CONTEXT    UNTIL
gpt-oss:120b    a951a23b46a1    66 GB    78%/22% CPU/GPU    4096       4 minutes from now

Comando Ollama launch (integraciones de codificación con IA)

ollama launch es un comando introducido en Ollama v0.15 (enero de 2026) que te da una configuración sin ajustes y de una línea para asistentes populares de codificación con IA 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 implicaba configurar manualmente variables de entorno, apuntar la herramienta al punto final de API correcto y elegir un modelo compatible. ollama launch maneja todo eso de forma interactiva.

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

Integraciones soportadas

La lista ha crecido mucho más allá de las cuatro integraciones de v0.15. A partir de Ollama v0.33, ollama launch soporta:

Uso básico

# Selector interactivo — elige una integración y un modelo de un menú
# (el selector de modelo siempre se muestra desde v0.16.3)
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

# Restablecer una integración a su perfil predeterminado
ollama launch codex --restore

# Pasar argumentos adicionales a la integración después de --
ollama launch codex -- --sandbox workspace-write

--yes (-y) responde automáticamente a las confirmaciones, lo cual es útil en scripts y flujos de incorporación.

Modelos recomendados

Los agentes de codificación necesitan una ventana de contexto larga para mantener el contexto de archivos completos y el historial de conversaciones de varios 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 (p. ej. qwen3-coder:480b-cloud) que se integran de la misma manera pero enrutan la inferencia al nivel 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 inicia Claude Code apuntando a http://localhost:11434 automáticamente. Entonces 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 colas o timeouts bajo carga, el primer ajuste que debes conocer es OLLAMA_NUM_PARALLEL.

• OLLAMA_NUM_PARALLEL = cuántas solicitudes ejecuta Ollama en paralelo.
• Un valor más alto puede aumentar el rendimiento, pero también puede aumentar la presión de VRAM y los picos de latencia.
• Las solicitudes que llegan cuando todos los slots paralelos están ocupados terminan en la cola; su profundidad está limitada por OLLAMA_MAX_QUEUE.

Ejemplo rápido:

OLLAMA_NUM_PARALLEL=2 ollama serve

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

• Cómo Ollama maneja las solicitudes paralelas

Liberar un modelo de Ollama de la VRAM (keep_alive)

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

• Liberar Modelo de VRAM usando curl:

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

Reemplaza NOMBREDELMODELO 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 particularmente útil cuando:

• Necesitas liberar memoria de 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, un valor negativo (p. ej. -1) mantiene el modelo cargado para siempre, y una cadena de duración (p. ej. 10m, 24h) también se acepta. El predeterminado a nivel de servidor es OLLAMA_KEEP_ALIVE=5m, y un keep_alive por solicitud siempre lo sobrescribe.

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 router de llama-server cubre el enfoque nativo de llama.cpp para el cambio dinámico de modelos.

Personalización de modelos de Ollama (prompt de sistema, Modelfile)

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

  >>> /set system Para todas las preguntas hechas, responde en inglés sencillo evitando jerga técnica siempre que 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 (p. ej., custom_model.txt) con la siguiente estructura:

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

  Luego, ejecuta:

  ollama create mimodelo -f custom_model.txt
  ollama run mimodelo
  

  Esto crea un modelo personalizado basado en las instrucciones del archivo. ollama create también puede cuantizar mientras construye — -q q4_K_M produce un GGUF Q4_K_M de una fuente no cuantizada (safetensors), --draft-quantize establece la cuantización para un modelo de borrador (decodificación especulativa), y --experimental habilita funciones de creación de modelos safetensors que aún están marcadas como experimentales.

Ollama signin y signout (autenticación de 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.

Qué desbloquea signin:

• Descargar y subir modelos privados desde tu cuenta u organización.
• Usar modelos alojados en la nube (p. ej. 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 pipeline de CI o un servidor sin cabeza donde el ollama signin interactivo no es práctico, crea una clave API en los ajustes de tu cuenta de Ollama y expónla como variable de entorno:

export OLLAMA_API_KEY=ollama_...
ollama pull miorg/modelo-privado

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

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

• Resumir Texto de 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 "Dime 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 salud." > 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 salud?"
    

  • Respuestas de un solo tirón sin la pista de razonamiento (en modelos de razonamiento):

    ollama run qwen3:14b --think=false --hidethinking "Cuáles son las últimas tendencias en IA, y cómo afectarán a la salud?"
    

• Procesamiento y Análisis de Datos:

  • Clasificar texto en sentimiento positivo, negativo o neutro:

    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.

Usar 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 integraciones avanzadas en Python, explora usar la API de Búsqueda Web de Ollama en Python, que cubre capacidades de búsqueda web, invocación de herramientas e integración con servidores MCP.

¿Buscas una interfaz basada en la web? Open WebUI proporciona una interfaz autoalojada con capacidades de RAG y soporte multiusuario.

Enlaces útiles

Configuración y Gestión

• Mover Modelos de Ollama a Otra Unidad o Carpeta
• Ollama en Docker Compose con GPU y Almacenamiento Persistente de Modelos

Alternativas y Comparaciones

• Alojamiento Local de LLM: Guía Completa 2026 - Ollama, vLLM, LocalAI, Jan, LM Studio y Más
• llama.cpp vs Ollama en 2026: ¿Qué Runtime Deberías Usar?
• Inicios Rápidos de vLLM: Servicio de Alto Rendimiento de LLM
• Docker Model Runner vs Ollama: ¿Cuál Elegir?
• Primeras Señales de la Enshittification 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 Utiliza los Núcleos de Rendimiento y Eficiencia de la CPU de Intel
• NVIDIA DGX Spark vs Mac Studio vs RTX-4080: Comparación de Rendimiento de Ollama

Integración y Desarrollo

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