Cómo usar Ollama: Guía Completa para Principiantes sobre LLMs Locales con Ollama

El panorama de la inteligencia artificial evoluciona constantemente, y los Grandes Modelos de Lenguaje (LLM) se vuelven cada vez más potentes y accesibles. Aunque muchos interactúan con estos modelos a través de servicios basados en la nube, existe un movimiento creciente enfocado en ejecutarlos directamente en computadoras personales. Aquí es donde entra Ollama. Ollama es una herramienta potente pero fácil de usar, diseñada para simplificar drásticamente el complejo proceso de descargar, configurar y ejecutar LLMs de vanguardia como Llama 3, Mistral, Gemma, Phi y muchos otros, localmente.

Esta guía completa te servirá como punto de partida para dominar Ollama. Recorreremos desde los pasos iniciales de instalación y las interacciones básicas con modelos hasta técnicas de personalización más avanzadas, uso de la API y solución de problemas esenciales. Ya seas un desarrollador que busca integrar IA local en tus aplicaciones, un investigador interesado en experimentar con diversas arquitecturas de modelos, o simplemente un entusiasta de la IA deseoso de explorar el potencial de ejecutar modelos potentes sin conexión, Ollama proporciona una puerta de entrada excepcionalmente optimizada y eficiente.

💡

¿Quieres una excelente herramienta de prueba de API que genere hermosa documentación de API?

¿Quieres una plataforma integrada y todo-en-uno para que tu equipo de desarrolladores trabaje junto con máxima productividad?

Apidog satisface todas tus demandas, y reemplaza a Postman a un precio mucho más asequible!

button

¿Por qué elegir Ollama para la Ejecución Local de LLM?

Antes de sumergirnos en los detalles técnicos, es crucial comprender las convincentes ventajas de usar Ollama para la operación local de LLM. ¿Por qué optar por este enfoque en lugar de depender únicamente de las API en la nube fácilmente disponibles?

Privacidad y Seguridad Incomparables con Ollama: Cuando ejecutas un LLM usando Ollama en tu máquina, cada dato – tus prompts, los documentos que proporcionas y el texto generado por el modelo – permanece confinado enteramente en tu sistema local. Nunca sale de tu hardware. Esto asegura el más alto nivel de privacidad y control de datos, un factor crítico al tratar con información personal sensible, datos comerciales confidenciales o investigación propietaria.
Ahorros de Costos Significativos a través de Ollama: Las API de LLM basadas en la nube a menudo operan con modelos de pago por uso o requieren tarifas de suscripción continuas. Estos costos pueden acumularse rápidamente, especialmente con un uso intensivo. Ollama elimina estos gastos recurrentes. Aparte de la inversión inicial en hardware adecuado (que podrías ya poseer), ejecutar modelos localmente es efectivamente gratuito, permitiendo experimentación y generación ilimitadas sin la preocupación inminente de las facturas de API.
Verdadera Capacidad Offline con Ollama: Una vez que un modelo de Ollama se descarga en tu almacenamiento local, es tuyo para usarlo en cualquier momento y lugar, completamente independiente de una conexión a internet. Este acceso sin conexión es invaluable para desarrolladores que trabajan en entornos con conectividad restringida, investigadores en campo, o cualquiera que necesite acceso fiable a la IA en movimiento.
Personalización Profunda y Experimentación vía Modelfiles de Ollama: Ollama se distingue por su potente sistema de Modelfile. Esto permite a los usuarios modificar fácilmente el comportamiento del modelo ajustando parámetros (como niveles de creatividad o longitud de salida), definiendo prompts de sistema personalizados para dar forma a la personalidad de la IA, o incluso integrando adaptadores especializados afinados (LoRAs). También puedes importar pesos de modelos directamente desde formatos estándar como GGUF o Safetensors. Este nivel granular de control y flexibilidad rara vez lo ofrecen los proveedores de API en la nube de código cerrado.
Ventajas Potenciales de Rendimiento con Ollama: Dependiendo de la configuración de tu hardware local, particularmente la presencia de una Unidad de Procesamiento Gráfico (GPU) capaz, Ollama puede ofrecer tiempos de respuesta (velocidad de inferencia) significativamente más rápidos en comparación con los servicios en la nube, que podrían estar sujetos a latencia de red, limitación de velocidad o carga variable en recursos compartidos. Aprovechar tu hardware dedicado puede llevar a una experiencia mucho más fluida e interactiva.
Participación en el Vibrante Ecosistema Open Source de Ollama: Ollama en sí mismo es un proyecto de código abierto, fomentando la transparencia y la contribución de la comunidad. Además, sirve principalmente como puerta de entrada a una vasta y rápidamente expansiva biblioteca de LLMs abiertamente accesibles. Al usar Ollama, te conviertes en parte de este ecosistema dinámico, beneficiándote del conocimiento compartido, el apoyo de la comunidad y la constante innovación impulsada por la colaboración abierta.

El principal logro de Ollama es ocultar las complejidades inherentes involucradas en la configuración de los entornos de software necesarios, la gestión de dependencias y la configuración de los intrincados ajustes requeridos para ejecutar estos sofisticados modelos de IA. Utiliza hábilmente motores de inferencia backend altamente optimizados, notablemente la renombrada biblioteca llama.cpp, para asegurar una ejecución eficiente en hardware de consumo estándar, soportando tanto la aceleración por CPU como por GPU.

Entendiendo Ollama vs. Llama.cpp

Es beneficioso aclarar la relación entre Ollama y llama.cpp, ya que están estrechamente relacionados pero sirven a propósitos diferentes.

llama.cpp: Esta es la biblioteca C/C++ fundamental y de alto rendimiento responsable de la tarea central de la inferencia de LLM. Maneja la carga de pesos del modelo, el procesamiento de tokens de entrada y la generación eficiente de tokens de salida, con optimizaciones para diversas arquitecturas de hardware (conjuntos de instrucciones de CPU como AVX, aceleración de GPU a través de CUDA, Metal, ROCm). Es el potente motor que realiza el trabajo pesado computacional.
Ollama: Esta es una aplicación integral construida alrededor de llama.cpp (y potencialmente otros backends futuros). Ollama proporciona una capa fácil de usar encima, ofreciendo:
Una Interfaz de Línea de Comandos (CLI) simple para una fácil interacción (ollama run, ollama pull, etc.).
Un servidor API REST incorporado para integración programática.
Gestión de modelos optimizada (descarga desde una biblioteca, almacenamiento local, actualizaciones).
El sistema Modelfile para personalización y creación de variantes de modelos.
Instaladores multiplataforma (macOS, Windows, Linux) e imágenes Docker.
Detección y configuración automática de hardware (CPU/GPU).

En esencia, aunque técnicamente podrías usar llama.cpp directamente compilándolo y ejecutando sus herramientas de línea de comandos, esto requiere un esfuerzo técnico significativamente mayor en cuanto a configuración, conversión de modelos y gestión de parámetros. Ollama empaqueta esta potencia en una aplicación accesible y fácil de usar, haciendo que los LLMs locales sean prácticos para una audiencia mucho más amplia, especialmente para principiantes. Piensa en llama.cpp como los componentes del motor de alto rendimiento, y en Ollama como el vehículo completamente ensamblado y fácil de usar, listo para conducir.

Instalando Ollama en tu Sistema

Ollama está diseñado para ser accesible, ofreciendo procedimientos de instalación sencillos para macOS, Windows, Linux y entornos Docker.

Requisitos Generales del Sistema para Ollama:

RAM (Memoria): Este es a menudo el factor más crítico.
Mínimo 8 GB: Suficiente para modelos más pequeños (ej., 1B, 3B, 7B parámetros), aunque el rendimiento puede ser lento.
Recomendado 16 GB: Un buen punto de partida para ejecutar modelos de 7B y 13B cómodamente.
Ideal 32 GB o más: Necesario para modelos más grandes (30B, 40B, 70B+) y permite ventanas de contexto más grandes. Más RAM generalmente conduce a un mejor rendimiento y la capacidad de ejecutar modelos más grandes y capaces.
Espacio en Disco: La aplicación Ollama en sí es relativamente pequeña (unos pocos cientos de MB). Sin embargo, los LLMs que descargas requieren un espacio considerable. Los tamaños de los modelos varían enormemente:
Modelos Cuantizados Pequeños (ej., ~3B Q4): ~2 GB
Modelos Cuantizados Medianos (ej., 7B/8B Q4): 4-5 GB
Modelos Cuantizados Grandes (ej., 70B Q4): ~40 GB
Modelos Muy Grandes (ej., 405B): ¡Más de 200 GB!
Asegúrate de tener suficiente espacio libre en la unidad donde Ollama almacena los modelos (ver sección abajo).
Sistema Operativo:
macOS: Versión 11 Big Sur o posterior. Se recomienda Apple Silicon (M1/M2/M3/M4) para la aceleración de GPU.
Windows: Windows 10 versión 22H2 o posterior, o Windows 11. Se admiten las ediciones Home y Pro.
Linux: Una distribución moderna (ej., Ubuntu 20.04+, Fedora 38+, Debian 11+). Pueden aplicarse requisitos del kernel, especialmente para el soporte de GPU AMD.

Instalando Ollama en macOS

Descargar: Obtén el archivo DMG de la aplicación Ollama para macOS directamente desde el sitio web oficial de Ollama.
Montar: Haz doble clic en el archivo .dmg descargado para abrirlo.
Instalar: Arrastra el icono Ollama.app a tu carpeta de Aplicaciones.
Ejecutar: Abre la aplicación Ollama desde tu carpeta de Aplicaciones. Es posible que necesites concederle permiso para ejecutarse la primera vez.
Servicio en Segundo Plano: Ollama comenzará a ejecutarse como un servicio en segundo plano, indicado por un icono en tu barra de menú. Hacer clic en este icono proporciona opciones para salir de la aplicación o ver los registros.

Al iniciar la aplicación, se inicia automáticamente el proceso del servidor Ollama y se agrega la herramienta de línea de comandos ollama al PATH de tu sistema, haciéndola inmediatamente disponible en la aplicación Terminal (Terminal.app, iTerm2, etc.). En Macs equipados con Apple Silicon (chips M1, M2, M3, M4), Ollama utiliza sin problemas la GPU incorporada para la aceleración a través de la API gráfica Metal de Apple sin requerir ninguna configuración manual.

Instalando Ollama en Windows

Descargar: Obtén el archivo instalador OllamaSetup.exe del sitio web de Ollama.
Ejecutar Instalador: Haz doble clic en el archivo .exe descargado para iniciar el asistente de configuración. Asegúrate de cumplir con el requisito mínimo de versión de Windows (10 22H2+ o 11).
Seguir Indicaciones: Procede a través de los pasos de instalación, aceptando el acuerdo de licencia y eligiendo la ubicación de instalación si lo deseas (aunque la predeterminada suele estar bien).

El instalador configura Ollama para que se ejecute automáticamente como un servicio en segundo plano cuando se inicia el sistema. También agrega el ejecutable ollama.exe al PATH de tu sistema, permitiéndote usar el comando ollama en terminales estándar de Windows como el Símbolo del sistema (cmd.exe), PowerShell o el nuevo Terminal de Windows. El servidor API de Ollama se inicia automáticamente y escucha en http://localhost:11434.

Aceleración de GPU de Ollama para Windows:

NVIDIA: Instala los últimos controladores GeForce Game Ready o NVIDIA Studio desde el sitio web de NVIDIA. Se requiere la versión de controlador 452.39 o posterior. Ollama debería detectar y utilizar automáticamente las GPU compatibles.
AMD: Instala los últimos controladores AMD Software: Adrenalin Edition desde el sitio web de soporte de AMD. Las GPU Radeon compatibles (generalmente la serie RX 6000 y posteriores) se utilizarán automáticamente.

Instalando Ollama en Linux

El método más conveniente para la mayoría de las distribuciones de Linux es usar el script de instalación oficial:

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

Este comando descarga el script y lo ejecuta usando sh. El script realiza las siguientes acciones:

Detecta la arquitectura de tu sistema (x86_64, ARM64).
Descarga el binario de Ollama apropiado.
Instala el binario en /usr/local/bin/ollama.
Verifica los controladores de GPU necesarios (NVIDIA CUDA, AMD ROCm) e instala dependencias si es posible (esta parte puede variar según la distribución).
Crea un usuario y grupo del sistema ollama dedicados.
Configura un archivo de servicio systemd (/etc/systemd/system/ollama.service) para gestionar el proceso del servidor Ollama.
Habilita e inicia el servicio ollama, para que se ejecute automáticamente en el arranque y en segundo plano.

Instalación Manual de Ollama en Linux y Configuración de Systemd:
Si el script falla, o si prefieres el control manual (ej., instalar en una ubicación diferente, gestionar usuarios de manera diferente, asegurar versiones específicas de ROCm), consulta la guía detallada de instalación de Linux en el repositorio de GitHub de Ollama. Los pasos generales implican:

Descargar el binario correcto para tu arquitectura.
Hacer el binario ejecutable (chmod +x ollama) y moverlo a una ubicación en tu PATH (ej., /usr/local/bin).
(Recomendado) Crear un usuario/grupo del sistema: sudo useradd -r -s /bin/false -m -d /usr/share/ollama ollama y sudo groupadd ollama, luego sudo usermod -a -G ollama ollama. Agrega tu propio usuario al grupo: sudo usermod -a -G ollama $USER.
Crear el archivo de servicio systemd (/etc/systemd/system/ollama.service) con la configuración apropiada (usuario, grupo, ruta del ejecutable, variables de entorno si es necesario). Normalmente se proporcionan fragmentos de ejemplo en la documentación.
Recargar el demonio systemd: sudo systemctl daemon-reload.
Habilitar el servicio para que se inicie en el arranque: sudo systemctl enable ollama.
Iniciar el servicio inmediatamente: sudo systemctl start ollama. Puedes verificar su estado con sudo systemctl status ollama.

Controladores Esenciales de GPU para Ollama en Linux:
Para un rendimiento óptimo, se recomienda encarecidamente instalar los controladores de GPU:

NVIDIA: Instala los controladores propietarios oficiales de NVIDIA para tu distribución (ej., a través de un gestor de paquetes como apt o dnf, o descargados del sitio web de NVIDIA). Verifica la instalación usando el comando nvidia-smi.
AMD (ROCm): Instala el kit de herramientas ROCm. AMD proporciona repositorios oficiales y guías de instalación para distribuciones compatibles (como Ubuntu, RHEL/CentOS, SLES). Asegúrate de que la versión de tu kernel sea compatible. El script de instalación de Ollama puede manejar algunas dependencias de ROCm, pero la instalación manual garantiza una configuración correcta. Verifica con rocminfo.

Usando la Imagen Docker Oficial de Ollama

Docker ofrece una forma independiente de la plataforma para ejecutar Ollama en un contenedor aislado, simplificando la gestión de dependencias, especialmente para configuraciones complejas de GPU.

Contenedor Ollama Solo CPU:

docker run -d \
  -v ollama_data:/root/.ollama \
  -p 127.0.0.1:11434:11434 \
  --name my_ollama \
  ollama/ollama

-d: Ejecuta el contenedor en modo detached (segundo plano).
-v ollama_data:/root/.ollama: Crea un volumen nombrado de Docker llamado ollama_data en tu sistema host y lo mapea al directorio /root/.ollama dentro del contenedor. Esto es crucial para persistir tus modelos descargados. Si omites esto, los modelos se perderán cuando se elimine el contenedor. Puedes elegir cualquier nombre para el volumen.
-p 127.0.0.1:11434:11434: Mapea el puerto 11434 en la interfaz loopback de tu máquina host (127.0.0.1) al puerto 11434 dentro del contenedor. Usa 0.0.0.0:11434:11434 si necesitas acceder al contenedor Ollama desde otras máquinas en tu red.
--name my_ollama: Asigna un nombre personalizado y memorable al contenedor en ejecución.
ollama/ollama: Especifica la imagen oficial de Ollama desde Docker Hub.

Contenedor Ollama con GPU NVIDIA:

Primero, asegúrate de que el NVIDIA Container Toolkit esté correctamente instalado en tu máquina host y que Docker esté configurado para usar el runtime de NVIDIA.
Ejecuta el contenedor, añadiendo la bandera --gpus=all:

docker run -d \
  --gpus=all \
  -v ollama_data:/root/.ollama \
  -p 127.0.0.1:11434:11434 \
  --name my_ollama_gpu \
  ollama/ollama

Esta bandera otorga al contenedor acceso a todas las GPU NVIDIA compatibles detectadas por el toolkit. Puedes especificar GPUs particulares si es necesario (ej., --gpus '"device=0,1"').

Contenedor Ollama con GPU AMD (ROCm):

Usa la etiqueta de imagen específica de ROCm: ollama/ollama:rocm.
Mapea los nodos de dispositivo ROCm necesarios desde el host al contenedor:

docker run -d \
  --device /dev/kfd \
  --device /dev/dri \
  -v ollama_data:/root/.ollama \
  -p 127.0.0.1:11434:11434 \
  --name my_ollama_rocm \
  ollama/ollama:rocm

/dev/kfd: La interfaz del controlador de fusión del kernel.
/dev/dri: Dispositivos de Infraestructura de Renderizado Directo (a menudo incluye nodos de renderizado como /dev/dri/renderD128).
Asegúrate de que el usuario que ejecuta el comando docker en el host tenga los permisos apropiados para acceder a estos archivos de dispositivo (puede ser necesaria la membresía en grupos como render y video).

Una vez que el contenedor Ollama esté en ejecución, puedes interactuar con él usando el comando docker exec para ejecutar comandos CLI de ollama dentro del contenedor:

docker exec -it my_ollama ollama list
docker exec -it my_ollama ollama pull llama3.2
docker exec -it my_ollama ollama run llama3.2

Alternativamente, si mapeaste el puerto (-p), puedes interactuar con la API de Ollama directamente desde tu máquina host u otras aplicaciones que apunten a http://localhost:11434 (o la IP/puerto que mapeaste).

¿Dónde almacena Ollama los modelos? Entendiendo las Ubicaciones de Almacenamiento de Ollama

Saber dónde guarda Ollama sus modelos descargados es esencial para gestionar el espacio en disco y las copias de seguridad. La ubicación predeterminada varía según el sistema operativo y el método de instalación:

Ollama en macOS: Los modelos residen dentro del directorio home de tu usuario en ~/.ollama/models. ~ representa /Users/<TuNombreDeUsuario>.
Ollama en Windows: Los modelos se almacenan en el directorio de perfil de tu usuario en C:\Users\<TuNombreDeUsuario>\.ollama\models.
Ollama en Linux (Instalación de Usuario / Manual): Similar a macOS, los modelos se almacenan típicamente en ~/.ollama/models.
Ollama en Linux (Instalación de Servicio Systemd): Cuando se instala mediante el script o se configura como un servicio para todo el sistema ejecutándose como el usuario ollama, los modelos a menudo se almacenan en /usr/share/ollama/.ollama/models. Verifica la configuración del servicio o la documentación si utilizaste una configuración no estándar.
Ollama vía Docker: Dentro del contenedor, la ruta es /root/.ollama/models. Sin embargo, si usaste correctamente la bandera -v para montar un volumen Docker (ej., -v ollama_data:/root/.ollama), los archivos reales del modelo se almacenan dentro del área de volúmenes gestionados de Docker en tu máquina host. La ubicación exacta de los volúmenes Docker depende de tu configuración de Docker, pero están diseñados para persistir independientemente del contenedor.

Puedes redirigir la ubicación de almacenamiento de modelos usando la variable de entorno OLLAMA_MODELS, que cubriremos en la sección de Configuración. Esto es útil si tu unidad principal tiene poco espacio y prefieres almacenar modelos grandes en una unidad secundaria.

Tus Primeros Pasos con Ollama: Ejecutando un LLM

Ahora que Ollama está instalado y el servidor está activo (ejecutándose a través de la aplicación de escritorio, el servicio systemd o el contenedor Docker), puedes comenzar a interactuar con los LLMs usando el sencillo comando ollama en tu terminal.

Descargando Modelos de Ollama: El Comando `pull`

Antes de poder ejecutar un LLM específico, primero debes descargar sus pesos y archivos de configuración. Ollama proporciona una biblioteca curada de modelos abiertos populares, fácilmente accesibles a través del comando ollama pull. Puedes explorar los modelos disponibles en la página de la biblioteca del sitio web de Ollama.

# Ejemplo 1: Descargar el último modelo Llama 3.2 8B Instruct
# A menudo etiquetado como 'latest' o simplemente por el nombre base.
ollama pull llama3.2

# Ejemplo 2: Descargar una versión específica de Mistral (7 mil millones de parámetros, modelo base)
ollama pull mistral:7b

# Ejemplo 3: Descargar el modelo Gemma 3 4B de Google
ollama pull gemma3

# Ejemplo 4: Descargar el modelo Phi-4 Mini más pequeño de Microsoft (eficiente)
ollama pull phi4-mini

# Ejemplo 5: Descargar un modelo de visión (puede procesar imágenes)
ollama pull llava

Entendiendo las Etiquetas de Modelo de Ollama:
Los modelos en la biblioteca de Ollama utilizan una convención de nomenclatura nombre_familia_modelo:etiqueta. La etiqueta especifica variaciones como:

Tamaño: 1b, 3b, 7b, 8b, 13b, 34b, 70b, 405b (indicando miles de millones de parámetros). Los modelos más grandes generalmente tienen más conocimiento pero requieren más recursos.
Cuantización: q2_K, q3_K_S, q4_0, q4_K_M, q5_1, q5_K_M, q6_K, q8_0, f16 (float16), f32 (float32). La cuantización reduce el tamaño del modelo y las necesidades computacionales, a menudo con una ligera pérdida de precisión. Números más bajos (ej., q4) significan más compresión. Las variantes K (_K_S, _K_M, _K_L) generalmente se consideran un buen equilibrio entre tamaño y calidad. f16/f32 no están cuantizados o están mínimamente comprimidos, ofreciendo la más alta fidelidad pero requiriendo la mayor cantidad de recursos.
Variante: instruct (ajustado para seguir instrucciones), chat (ajustado para conversación), code (optimizado para tareas de programación), vision (multimodal, maneja imágenes), uncensored (menos filtrado de seguridad, usar responsablemente).
latest: Si omites una etiqueta (ej., ollama pull llama3.2), Ollama típicamente usa la etiqueta latest por defecto, que usualmente apunta a una versión comúnmente usada y bien equilibrada (a menudo un modelo de tamaño mediano, cuantizado y ajustado para instrucciones).

El comando pull descarga los archivos necesarios (que pueden ser varios gigabytes) a tu directorio de modelos de Ollama designado. Solo necesitas descargar una combinación específica de modelo:etiqueta una vez. Ollama también puede actualizar modelos; ejecutar pull nuevamente en un modelo existente descargará solo las capas modificadas (diferencias), haciendo las actualizaciones eficientes.

Chat Interactivo con Modelos de Ollama: El Comando `run`

La forma más directa de conversar con un modelo descargado es usando el comando ollama run:

ollama run llama3.2

Si el modelo especificado (llama3.2:latest en este caso) aún no ha sido descargado, ollama run convenientemente activará ollama pull primero. Una vez que el modelo esté listo y cargado en la memoria (lo que puede tardar unos segundos, especialmente para modelos más grandes), se te presentará un prompt interactivo:

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

Ahora, simplemente puedes escribir tu pregunta o instrucción, presionar Enter y esperar a que la IA genere una respuesta. La salida típicamente se transmite token por token, proporcionando una sensación receptiva.

>>> Explica el concepto de entrelazamiento cuántico en términos simples.
De acuerdo, imagina que tienes dos monedas especiales que están vinculadas de una manera mágica. Llamémoslas Moneda A y Moneda B. Antes de mirarlas, ninguna moneda es cara o cruz – están en una mezcla difusa de ambas posibilidades.

Ahora, le das la Moneda A a un amigo y viajas años luz de distancia con la Moneda B. En el instante en que miras tu Moneda B y ves que es, digamos, cara, instantáneamente sabes *con seguridad* que la Moneda A de tu amigo es cruz. Y si vieras cruz, sabrías que la de ellos es cara.

¡Eso es algo así como el entrelazamiento cuántico! Dos partículas (como nuestras monedas) se vinculan, y sus propiedades (como cara/cruz) permanecen correlacionadas sin importar cuán separadas estén. Medir una influye instantáneamente en la propiedad de la otra, más rápido de lo que la luz podría viajar entre ellas. ¡Es una de las partes más extrañas y geniales de la física cuántica!

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

Comandos Útiles dentro del Modo Interactivo de Ollama:
Mientras interactúas con un modelo vía ollama run, puedes usar comandos especiales prefijados con /:

/?: Muestra un menú de ayuda listando todos los comandos de barra disponibles.
/set parameter <nombre_parametro> <valor>: Modifica temporalmente un parámetro de tiempo de ejecución del modelo para la sesión de chat actual. Por ejemplo, /set parameter temperature 0.9 aumenta la creatividad, mientras que /set parameter num_ctx 8192 aumenta la ventana de contexto para esta sesión.
/show info: Imprime información detallada sobre el modelo actualmente cargado, incluyendo sus parámetros, estructura de plantilla y licencia.
/show modelfile: Muestra el contenido del Modelfile que se usó para crear el modelo actualmente en ejecución. Esto es útil para entender su modelo base, parámetros y plantilla de prompt.
/save <nombre_sesion>: Guarda el historial de chat actual en un archivo de sesión nombrado.
/load <nombre_sesion>: Carga una sesión de chat previamente guardada, restaurando el historial de la conversación.
/bye o /exit: Sale elegantemente de la sesión de chat interactiva y descarga el modelo de la memoria (si ninguna otra sesión lo está usando). Normalmente también puedes salir usando Ctrl+D.

Gestionando tus Modelos Locales de Ollama

A medida que descargas y creas modelos, necesitarás formas de gestionarlos:

Listar Modelos de Ollama Descargados: Para ver todos los modelos actualmente almacenados localmente, usa:

ollama list

Este comando muestra una tabla con el nombre del modelo (NAME), ID único, tamaño en disco (SIZE) y tiempo de modificación (MODIFIED).

Mostrar Información Detallada del Modelo de Ollama: Para inspeccionar los detalles de un modelo en particular (sus parámetros, prompt del sistema, plantilla, etc.), usa:

ollama show llama3.2:8b-instruct-q5_K_M

Esto imprimirá el contenido del Modelfile, la configuración de parámetros, los detalles de la plantilla y otros metadatos asociados con esa etiqueta de modelo específica.

Eliminar un Modelo de Ollama: Si ya no necesitas un modelo y quieres liberar espacio en disco, usa:

ollama rm mistral:7b

Esto elimina permanentemente la combinación modelo:etiqueta especificada de tu almacenamiento. ¡Úsalo con precaución!

Copiar/Renombrar un Modelo de Ollama: Para crear un duplicado de un modelo existente, quizás como punto de partida para la personalización o simplemente para darle un nombre diferente, usa:

ollama cp llama3.2 mi-config-llama3.2-personalizada

Esto crea una nueva entrada de modelo llamada mi-config-llama3.2-personalizada basada en el llama3.2 original.

Verificar Modelos de Ollama Cargados Actualmente: Para ver qué modelos están cargados activamente en tu RAM o VRAM y listos para inferencia inmediata, usa:

ollama ps

Este comando muestra el nombre del modelo, ID, tamaño, procesador utilizado (CPU/GPU) y cuánto tiempo hace que se accedió por última vez. Los modelos suelen permanecer cargados durante un corto período después de su uso (ej., 5 minutos) para acelerar las solicitudes posteriores, luego se descargan automáticamente para liberar recursos.

¿Cuáles son los mejores modelos de Ollama? Seleccionando el LLM Adecuado

Esta es una pregunta frecuente e importante, pero la respuesta es matizada. No existe un único modelo Ollama "mejor" para todos o para cada tarea. La elección óptima depende de varios factores:

Tu Tarea Específica: ¿Qué quieres principalmente que haga la IA?
Chat/Asistencia General: llama3.2, llama3.1, mistral, gemma3, qwq son fuertes contendientes.
Codificación/Programación: codellama, phi4, phi4-mini, starcoder2, deepseek-coder están específicamente ajustados para la generación, explicación y depuración de código.
Escritura Creativa: Modelos con temperaturas predeterminadas más altas o mayor número de parámetros (como los modelos 70B) podrían producir resultados más imaginativos. La experimentación es clave.
Resumen/Análisis: Los modelos ajustados para instrucciones (etiqueta :instruct) a menudo sobresalen aquí.
Multimodal (Entrada de Imagen): llava, moondream, llama3.2-vision.
Tus Recursos de Hardware (RAM y VRAM): Esta es una limitación importante.
Recursos Bajos (8GB RAM, Sin/GPU Débil): Apégate a modelos más pequeños (1B-3B parámetros) o versiones muy cuantizadas (ej., q2_K, q3_K_S) de modelos 7B. El rendimiento será más lento. Ejemplos: gemma3:1b, llama3.2:1b, phi4-mini:q4_0.
Recursos de Rango Medio (16GB RAM, GPU Básica): Puedes ejecutar cómodamente modelos 7B/8B (ej., llama3.2, mistral, gemma3) con buena cuantización (q4_K_M, q5_K_M). Podrías ejecutar modelos 13B (q4_0) lentamente.
Recursos de Gama Alta (32GB+ RAM, GPU Fuerte con 12GB+ VRAM): Puedes ejecutar modelos más grandes como 13B, 30B o incluso 70B (cuantización q4_K_M o mejor como q5_K_M, q6_K). Estos ofrecen razonamiento y conocimiento significativamente mejores. Ejemplos: llama3.3, llama3.1:405b (requiere recursos masivos), gemma3:27b, deepseek-r1:671b (requisitos extremos).
Compromiso Deseado entre Calidad y Velocidad:
Mayor Calidad: Mayor número de parámetros y cuantización menos agresiva (ej., q6_K, q8_0, f16) generalmente proporcionan mejores resultados pero son más lentos y requieren más recursos.
Mayor Velocidad/Menor Uso de Recursos: Menor número de parámetros y cuantización más agresiva (ej., q4_0, q4_K_M, q3_K_M) son más rápidos y ligeros pero podrían exhibir una coherencia o precisión ligeramente reducidas. Las cuantizaciones K (_K_M, _K_S) a menudo proporcionan el mejor equilibrio.
Ajuste y Alineación del Modelo: Algunos modelos son modelos base, mientras que otros están ajustados para instrucciones (instruct) o para chat (chat). Los modelos Instruct/chat generalmente son mejores para seguir direcciones y participar en conversaciones. Los modelos sin censura tienen menos barreras de seguridad.

Recomendaciones para Principiantes (Finales de 2024):

Buen Todoterreno (Hardware de Rango Medio): llama3.2:8b-instruct-q5_K_M o mistral:7b-instruct-v0.2-q5_K_M. Ofrecen un gran equilibrio entre capacidad, velocidad y uso de recursos.
Opción Eficiente (Hardware de Gama Baja): phi4-mini:q4_K_M o gemma3:1b. Sorprendentemente capaces para su tamaño.
Enfoque en Codificación: codellama:7b-instruct-q5_K_M.
Necesidades de Visión: llava:13b (si los recursos lo permiten) o moondream.

El mejor enfoque es empírico: Lee las descripciones de los modelos en la biblioteca de Ollama, considera tu hardware, descarga algunos candidatos probables usando ollama pull, pruébalos con tus prompts típicos usando ollama run, y mira cuál funciona mejor para ti. No dudes en usar ollama rm para eliminar modelos que no satisfagan tus necesidades y así ahorrar espacio.

Desmitificando los Conceptos de Modelos de Ollama

Para usar y personalizar Ollama eficazmente, ayuda entender algunos conceptos centrales de LLM.

Parámetros de Modelo de Ollama Explicados

Los LLMs tienen configuraciones internas, o parámetros, que puedes ajustar para influir en cómo generan texto. Ollama te permite controlar muchos de estos:

temperature: (Predeterminado: ~0.7-0.8) Controla la aleatoriedad o "creatividad" de la salida.
Valores bajos (ej., 0.2): Hacen la salida más determinista, enfocada y predecible. Bueno para respuestas factuales o generación de código.
Valores altos (ej., 1.0, 1.2): Aumentan la aleatoriedad, haciendo la salida más diversa y creativa, pero potencialmente menos coherente. Bueno para lluvia de ideas o escritura de historias.
top_p (Muestreo Nucleus): (Predeterminado: ~0.9) Establece un umbral de probabilidad. El modelo considera solo los tokens siguientes más probables cuya masa de probabilidad acumulada excede top_p. Bajar top_p (ej., 0.5) restringe las opciones a palabras más probables, aumentando la coherencia pero potencialmente reduciendo la novedad. Valores más altos permiten opciones más diversas.
top_k: (Predeterminado: ~40) Limita las opciones del modelo a los k tokens siguientes más probables. Un top_k más bajo (ej., 10) hace la salida más enfocada; un top_k más alto permite más variedad. top_p a menudo se considera más efectivo que top_k. Usualmente, estableces uno u otro, no ambos bajos.
num_predict: (Predeterminado: ~128, -1 para infinito) Número máximo de tokens (aproximadamente palabras/subpalabras) que el modelo generará en una sola respuesta. Establece en -1 para generación ilimitada hasta que se cumpla una condición de parada.
stop: Una lista de secuencias de texto específicas. Si el modelo genera una de estas secuencias, detendrá inmediatamente la producción de más salida. Útil para prevenir frases continuas o asegurar que el modelo se detenga después de responder. Ejemplo: ["\n", "User:", "<|eot_id|>"].
num_ctx: Define el tamaño de la ventana de contexto del modelo. Ver explicación detallada abajo.
Otros parámetros: Ollama expone muchos otros parámetros heredados de llama.cpp (como repeat_penalty, seed, mirostat, capas de GPU num_gpu, etc.) para un control detallado. Consulta la documentación de Ollama y llama.cpp para más detalles.

Puedes establecer estos temporalmente usando /set parameter en ollama run, permanentemente en un Modelfile usando la instrucción PARAMETER, o por solicitud a través del objeto options en la API de Ollama.

Longitud de Contexto de Ollama: El Parámetro `num_ctx`

La longitud de contexto, a menudo referida como la ventana de contexto o num_ctx en la configuración de Ollama y llama.cpp, es una de las limitaciones arquitectónicas más críticas de un LLM.

Lo que representa: num_ctx define el número máximo de tokens que el modelo puede "ver" o procesar simultáneamente. Esto incluye todo: el prompt inicial del sistema, todos los mensajes anteriores del usuario y las respuestas del asistente en el historial de chat actual, y el último prompt de entrada del usuario.
Por qué es crucial: La capacidad de un modelo para generar respuestas relevantes, coherentes y contextualmente apropiadas depende en gran medida de su ventana de contexto.
Conversaciones Largas: Una ventana de contexto más grande permite al modelo "recordar" información de partes anteriores de la conversación, evitando que pierda el hilo o se repita.
Análisis de Documentos: Al procesar documentos grandes (ej., para resumen o respuesta a preguntas), la ventana de contexto determina cuánto del documento puede considerar el modelo a la vez.
Instrucciones Complejas: Las instrucciones que dependen de detalles proporcionados mucho antes en el prompt requieren una ventana de contexto suficiente para ser entendidas correctamente.
Límites Inherentes del Modelo: Cada LLM es preentrenado con una longitud de contexto máxima específica (ej., 2048, 4096, 8192, 32k, 128k, o incluso millones para modelos de investigación de vanguardia). Aunque puedes establecer num_ctx en Ollama, establecerlo más alto que el límite de entrenamiento original del modelo podría llevar a un comportamiento impredecible, rendimiento degradado (el modelo podría "olvidar" cosas fuera de su ventana entrenada), o errores. Establecerlo más bajo siempre es seguro pero limita la capacidad del modelo.
Consumo de Recursos: Procesar una ventana de contexto más grande requiere significativamente más RAM y VRAM (memoria de GPU) y tarda más computacionalmente. Necesitas equilibrar la capacidad de contexto deseada con las limitaciones de tu hardware.
Encontrar el num_ctx Predeterminado para un Modelo de Ollama: Usa el comando ollama show <nombre_modelo:etiqueta> y busca la línea PARAMETER num_ctx en la sección Modelfile mostrada. Los modelos Ollama usualmente vienen con un tamaño predeterminado razonable (ej., 4096 u 8192).
Cambiar el num_ctx para Ollama:
Temporalmente (durante ollama run): Usa el comando de barra: /set parameter num_ctx 8192
Por Solicitud API: Inclúyelo en el objeto JSON options: curl ... -d '{ "model": "...", "prompt": "...", "options": { "num_ctx": 8192 } }'
Persistentemente (Modelo Ollama Personalizado): Crea o modifica un Modelfile y añade o cambia la línea PARAMETER num_ctx <valor>, luego construye el modelo usando ollama create. Esto establece el tamaño de contexto predeterminado para ese modelo personalizado.

Elige un valor de num_ctx que se adapte a tus tareas típicas. Para preguntas y respuestas simples, una ventana más pequeña (ej., 4096) podría ser suficiente. Para chats largos o resumir documentos grandes, te beneficiarás de la ventana de contexto más grande que tu hardware y el modelo puedan soportar razonablemente (ej., 8192, 16384, o más si está disponible).

Ollama Avanzado: Desatando la API y la Personalización

Mientras que la CLI de ollama ofrece una fácil interacción directa, el verdadero potencial para integrar Ollama en flujos de trabajo y aplicaciones reside en su API REST incorporada y el sistema de personalización Modelfile.

Interactuando Programáticamente con la API de Ollama

Por defecto, el proceso del servidor Ollama (ya sea ejecutándose a través de la aplicación de escritorio, systemd o Docker) escucha las solicitudes HTTP entrantes en el puerto 11434 de tu máquina local (http://localhost:11434 o http://127.0.0.1:11434). Esta API permite que otros programas, scripts o interfaces web que se ejecutan en la misma máquina (u otras en la red, si está configurado) interactúen con los modelos de Ollama de forma programática.

Puntos Clave de la API de Ollama:

POST /api/generate: Se utiliza para generar completaciones de texto basadas en un único prompt no conversacional. Adecuado para tareas como expansión de texto, traducción simple o fragmentos de código rápidos. Requiere un cuerpo JSON con model y prompt.
POST /api/chat: Diseñado para interacciones conversacionales. Acepta una lista de mensajes, cada uno con un role (system, user o assistant) y content. Esto permite que el modelo mantenga el contexto a lo largo de múltiples turnos. Requiere un cuerpo JSON con model y messages.
POST /api/embeddings: Genera representaciones vectoriales numéricas (embeddings) para texto de entrada. Estos vectores capturan el significado semántico y son fundamentales para tareas como la Generación Aumentada por Recuperación (RAG), búsqueda semántica, clasificación de texto y agrupamiento. Requiere un cuerpo JSON con model y prompt.
GET /api/tags: Recupera una lista de todos los modelos disponibles actualmente en tu almacenamiento local de Ollama (equivalente a ollama list). Devuelve un array JSON de objetos de modelo.
POST /api/show: Obtiene información detallada sobre un modelo local específico, incluyendo sus parámetros, plantilla, licencia, etc. (equivalente a ollama show). Requiere un cuerpo JSON con name (modelo:etiqueta).
DELETE /api/delete: Elimina un modelo especificado del almacenamiento local (equivalente a ollama rm). Requiere un cuerpo JSON con name (modelo:etiqueta).
POST /api/pull: Inicia la descarga de un modelo desde la biblioteca de Ollama (equivalente a ollama pull). Requiere un cuerpo JSON con name (modelo:etiqueta). También puede transmitir información de progreso.
POST /api/create: Crea un nuevo modelo personalizado basado en el contenido de un Modelfile proporcionado (equivalente a ollama create -f). Requiere un cuerpo JSON con name (nuevo nombre de modelo) y modelfile (el contenido del Modelfile como una cadena).
POST /api/copy: Duplica un modelo local existente con un nuevo nombre (equivalente a ollama cp). Requiere un cuerpo JSON con source y destination.
POST /api/push: Sube un modelo local personalizado a tu cuenta en el registro de ollama.com (requiere inicio de sesión/configuración previa). Requiere un cuerpo JSON con name (nombre de modelo con espacio de nombres).

Formato de Solicitud/Respuesta API:
La mayoría de las solicitudes POST y DELETE esperan una carga útil JSON en el cuerpo de la solicitud. Las respuestas se devuelven típicamente como objetos JSON. Para los puntos finales generate y chat, puedes controlar el formato de la respuesta:

"stream": false (Predeterminado): La API espera hasta que se genere toda la respuesta y la devuelve como un único objeto JSON que contiene el texto completo, detalles de completación y estadísticas de rendimiento.
"stream": true: La API devuelve un flujo de objetos JSON, uno por cada token generado (o pequeño fragmento de tokens). Esto permite a las aplicaciones mostrar la respuesta progresivamente, proporcionando una experiencia de usuario más interactiva. El último objeto JSON en el flujo contiene las estadísticas generales.

Ejemplo de Interacción API usando curl:

1. Solicitud de Generación Simple (Sin Streaming):

curl http://localhost:11434/api/generate -d '{
  "model": "phi4-mini",
  "prompt": "Escribe una función corta en Python para calcular el factorial:",
  "stream": false,
  "options": {
    "temperature": 0.3,
    "num_predict": 80
  }
}'

2. Solicitud de Chat Conversacional (Streaming):

# Nota: La salida de streaming aparecerá como múltiples líneas JSON
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2:8b-instruct-q5_K_M",
  "messages": [
    { "role": "system", "content": "Eres un historiador experto." },
    { "role": "user", "content": "¿Cuáles fueron las principales causas de la Primera Guerra Mundial?" }
  ],
  "stream": true,
  "options": {
    "num_ctx": 4096
  }
}'

3. Solicitud de Generación de Embeddings:

curl http://localhost:11434/api/embeddings -d '{
  "model": "mxbai-embed-large",  # U otro modelo de embedding adecuado
  "prompt": "Ollama facilita la ejecución local de LLMs."
}'

Esta versátil API forma la columna vertebral de innumerables integraciones comunitarias, incluyendo interfaces de usuario web, herramientas de desarrollo, servicios backend, scripts de automatización y más, todo impulsado por tu instancia local de Ollama.

Aprovechando la API de Compatibilidad OpenAI de Ollama

Reconociendo la adopción generalizada de los estándares API de OpenAI, Ollama incluye cuidadosamente una capa de compatibilidad experimental. Esto permite que muchas herramientas, bibliotecas y aplicaciones diseñadas para los servicios de OpenAI funcionen con tu instancia local de Ollama con modificaciones mínimas, a menudo triviales.

Cómo Funciona:
El servidor Ollama expone puntos finales bajo la ruta /v1/ (ej., http://localhost:11434/v1/) que reflejan la estructura y los formatos de solicitud/respuesta esperados de los puntos finales clave de la API de OpenAI.

Puntos Finales Compatibles Clave:

/v1/chat/completions: Refleja el punto final de completación de chat de OpenAI.
/v1/embeddings: Refleja el punto final de embeddings de OpenAI.
/v1/models: Refleja el punto final de listado de modelos de OpenAI (devuelve tus modelos locales de Ollama).

Usando Bibliotecas Cliente de OpenAI con Ollama:
La principal ventaja es que puedes usar bibliotecas cliente estándar de OpenAI (como openai-python, openai-node, etc.) simplemente cambiando dos parámetros de configuración al inicializar el cliente:

base_url (o api_base): Establécelo a tu punto final local de Ollama v1: http://localhost:11434/v1/.
api_key: Proporciona cualquier cadena no vacía. El punto final /v1/ de Ollama en realidad no realiza autenticación e ignora el valor de la clave, pero la mayoría de las bibliotecas cliente de OpenAI requieren que el parámetro esté presente. La práctica común es usar la cadena "ollama" o "nokey".

Ejemplo de Python usando openai-python:

# Asegúrate de tener instalada la biblioteca openai: pip install openai
from openai import OpenAI
import os

# Define el punto final de Ollama y una clave API ficticia
OLLAMA_BASE_URL = "http://localhost:11434/v1"
OLLAMA_API_KEY = "ollama" # Marcador de posición, valor ignorado por Ollama

# Especifica el modelo local de Ollama que quieres usar
OLLAMA_MODEL = "llama3.2"

try:
    # Inicializa el cliente OpenAI, apuntándolo al servidor Ollama
    client = OpenAI(
        base_url=OLLAMA_BASE_URL,
        api_key=OLLAMA_API_KEY,
    )

    print(f"Enviando solicitud al modelo Ollama: {OLLAMA_MODEL} vía capa de compatibilidad OpenAI...")

    # Realiza una solicitud de completación de chat estándar
    chat_completion = client.chat.completions.create(
        model=OLLAMA_MODEL, # Usa el nombre de tu modelo local de Ollama
        messages=[
            {"role": "system", "content": "Eres un asistente útil."},
            {"role": "user", "content": "Explica la diferencia entre Ollama y llama.cpp."}
        ],
        temperature=0.7,
        max_tokens=250, # Nota: 'max_tokens' corresponde aproximadamente a 'num_predict' de Ollama
        stream=False # Establece en True para respuestas en streaming
    )

    # Procesa la respuesta
    if chat_completion.choices:
        response_content = chat_completion.choices[0].message.content
        print("\nRespuesta de Ollama:")
        print(response_content)
        print("\nEstadísticas de Uso:")
        print(f"  Tokens de Prompt: {chat_completion.usage.prompt_tokens}")
        print(f"  Tokens de Completación: {chat_completion.usage.completion_tokens}")
        print(f"  Tokens Totales: {chat_completion.usage.total_tokens}")
    else:
        print("No se recibieron opciones de respuesta de Ollama.")

except Exception as e:
    print(f"\nOcurrió un error:")
    print(f"  Tipo de Error: {type(e).__name__}")
    print(f"  Detalles del Error: {e}")
    print(f"\nAsegúrate de que el servidor Ollama esté ejecutándose y accesible en {OLLAMA_BASE_URL}.")
    print(f"También verifica que el modelo '{OLLAMA_MODEL}' esté disponible localmente ('ollama list').")

Esta compatibilidad simplifica significativamente la migración de proyectos existentes basados en OpenAI para usar modelos locales a través de Ollama o la construcción de nuevas aplicaciones que puedan cambiar flexiblemente entre backends en la nube y locales. Aunque no todas las características oscuras de OpenAI pueden estar perfectamente reflejadas, las funcionalidades principales de chat, embedding y listado de modelos están bien soportadas.

Personalización Profunda de Ollama con Modelfiles

El Modelfile es la piedra angular de las capacidades de personalización de Ollama. Actúa como un plano o receta, definiendo precisamente cómo se debe construir o modificar un modelo Ollama. Al crear y editar estos simples archivos de texto, obtienes un control detallado sobre el comportamiento, los parámetros y la estructura del modelo.

Instrucciones Principales del Modelfile de Ollama:

FROM <referencia_modelo_base>: (Instrucción Inicial Obligatoria) Especifica la base sobre la cual se construye tu nuevo modelo. La referencia puede apuntar a:
Un modelo existente en tu biblioteca local de Ollama o el registro oficial (ej., FROM llama3.2:8b-instruct-q5_K_M).
Una ruta relativa o absoluta a un directorio local que contenga pesos de modelo descomprimidos en formato Safetensors, junto con los archivos de configuración necesarios (config.json, tokenizer.json, etc.). Ejemplo: FROM /mnt/models/my_downloaded_llama/. Ollama intentará cargar arquitecturas compatibles (Llama, Mistral, Phi, Gemma, etc.).
Una ruta relativa o absoluta a un único archivo de modelo en el popular formato GGUF (que empaqueta pesos y metadatos). Ejemplo: FROM ./models/mistral-7b-instruct-v0.2.Q5_K_M.gguf.
PARAMETER <nombre_parametro> <valor>: Establece un valor de parámetro de tiempo de ejecución predeterminado para el modelo que se está creando. Estos valores predeterminados se usarán a menos que se anulen durante ollama run (vía /set parameter), a través de opciones de llamada API, o por instrucciones PARAMETER posteriores en el mismo Modelfile.
PARAMETER temperature 0.6
PARAMETER num_ctx 8192 (Establece la ventana de contexto predeterminada)
PARAMETER stop "<|user|>"
PARAMETER stop "<|end_of_turn|>" (Puedes tener múltiples parámetros de parada)
PARAMETER repeat_penalty 1.15
TEMPLATE "<cadena_plantilla_prompt>": Define el formato específico que Ollama debe usar para estructurar el prompt de entrada antes de alimentarlo al LLM subyacente. Esto es críticamente importante para los modelos de chat y seguimiento de instrucciones, ya que están entrenados para esperar tokens o marcadores especiales que delimitan mensajes del sistema, turnos del usuario y turnos del asistente. La plantilla utiliza la sintaxis text/template de Go. Las variables clave disponibles dentro de la cadena de plantilla incluyen:
{{ .System }}: Marcador de posición para el mensaje del sistema.
{{ .Prompt }}: Marcador de posición para la entrada actual del usuario (usado en /api/generate).
{{ .Response }}: Marcador de posición donde se anexará la salida generada por el modelo (a menudo usado internamente o para estructuras de plantilla específicas).
{{ range .Messages }} ... {{ .Role }} ... {{ .Content }} ... {{ end }}: Se usa en plantillas de chat (/api/chat) para iterar sobre todo el historial de mensajes (turnos del sistema, usuario, asistente) y formatearlo correctamente.
{{ .First }}: Un booleano que indica si el mensaje actual es el primero (útil para agregar tokens especiales de inicio de secuencia).
Ejemplo (plantilla ChatML simplificada):

TEMPLATE """{{ if .System }}<|im_start|>system
{{ .System }}<|im_end|>{{ end }}{{ range .Messages }}
<|im_start|>{{ .Role }}
{{ .Content }}<|im_end|>{{ end }}
<|im_start|>assistant
"""

Obtener la plantilla correcta es esencial para hacer que un modelo siga instrucciones o converse naturalmente. Puedes ver la plantilla predeterminada de un modelo usando ollama show --modelfile <nombre_modelo>.

SYSTEM "<mensaje_sistema_predeterminado>": Proporciona un prompt de sistema predeterminado que se usará si no se proporciona ningún otro mensaje del sistema a través de la API o CLI. Esto es útil para establecer una personalidad o conjunto de instrucciones consistente para el modelo.
SYSTEM "Eres un asistente de IA útil enfocado en proporcionar respuestas concisas."
ADAPTER </ruta/a/pesos_adaptador>: Aplica un adaptador LoRA (Low-Rank Adaptation) o QLoRA al modelo base especificado en la instrucción FROM. Los adaptadores son pequeños conjuntos de pesos entrenados para modificar o especializar un LLM preentrenado para una tarea, estilo o dominio de conocimiento específico sin reentrenar todo el modelo masivo. La ruta puede apuntar a:
Un único archivo .gguf que contiene el adaptador.
Un directorio que contiene los pesos del adaptador en formato Safetensors (adapter_model.safetensors, adapter_config.json).
Importante: El modelo base (FROM) debe ser el mismo en el que se entrenó originalmente el adaptador para que funcione correctamente.
LICENSE "<detalles_licencia>": Incrusta información de licencia dentro de los metadatos del modelo. Puede ser un identificador corto (como "MIT") o un bloque de texto más largo.
MESSAGE user "<mensaje_usuario_ejemplo>" / MESSAGE assistant "<respuesta_asistente_ejemplo>": Define turnos de conversación de ejemplo. Estos a veces pueden ayudar a guiar el tono, estilo o formato de salida esperado del modelo, especialmente para escenarios de prompting de pocos disparos, aunque su efecto varía entre modelos.

Construir un Modelo Ollama desde un Modelfile:
Una vez que hayas creado tu Modelfile (ej., guardado como MiModeloPersonalizado.modelfile), usa el comando ollama create para construir el modelo Ollama correspondiente:

ollama create mi-nuevo-nombre-modelo -f MiModeloPersonalizado.modelfile

Ollama procesa las instrucciones, potencialmente combina capas, aplica adaptadores, establece parámetros y registra el nuevo modelo (mi-nuevo-nombre-modelo) en tu biblioteca local. Luego puedes ejecutarlo como cualquier otro modelo: ollama run mi-nuevo-nombre-modelo.

Importando Modelos Externos a Ollama (GGUF, Safetensors)

El sistema Modelfile de Ollama proporciona una forma fluida de usar modelos obtenidos de otras fuentes (como Hugging Face, investigadores independientes, etc.) que se distribuyen en formatos estándar.

Importando Modelos GGUF a Ollama: GGUF es un formato popular diseñado específicamente para llama.cpp y motores de inferencia similares. Empaqueta pesos de modelo (a menudo pre-cuantizados), información del tokenizador y metadatos en un solo archivo. Este es a menudo el formato más fácil de importar.

Descarga el archivo .gguf (ej., zephyr-7b-beta.Q5_K_M.gguf).
Crea un Modelfile mínimo (ej., ZephyrImport.modelfile):

# ZephyrImport.modelfile
FROM ./zephyr-7b-beta.Q5_K_M.gguf

# Crucial: ¡Añade la plantilla de prompt correcta para este modelo!
# (Busca el formato de plantilla requerido por el modelo)
TEMPLATE """<|system|>
{{ .System }}</s>
<|user|>
{{ .Prompt }}</s>
<|assistant|>
{{ .Response }}</s>
"""
PARAMETER num_ctx 4096 # Establece un contexto predeterminado razonable
SYSTEM "Eres un chatbot amigable." # Prompt de sistema predeterminado opcional

Construye el modelo Ollama: ollama create mi-zephyr-gguf -f ZephyrImport.modelfile.

Importando Modelos Safetensors (Pesos Completos) a Ollama: Safetensors es un formato seguro y rápido para almacenar tensores de modelos. Si tienes el conjunto completo de pesos y archivos de configuración para un modelo en este formato:

Asegúrate de que todos los archivos necesarios (archivos de pesos *.safetensors, config.json, tokenizer.json, special_tokens_map.json, tokenizer_config.json, etc.) estén ubicados dentro de un solo directorio (ej., /data/models/Mistral-7B-v0.1-full/).
Crea un Modelfile que haga referencia a este directorio:

# MistralImport.modelfile
FROM /data/models/Mistral-7B-v0.1-full/

# Añade las instrucciones TEMPLATE, PARAMETER, SYSTEM requeridas
TEMPLATE """[INST] {{ if .System }}{{ .System }} \n{{ end }}{{ .Prompt }} [/INST]
{{ .Response }}"""
PARAMETER num_ctx 4096
PARAMETER temperature 0.7

Construye el modelo: ollama create mi-mistral-safetensors -f MistralImport.modelfile. Ollama intentará cargar arquitecturas compatibles. Si el modelo no está cuantizado (ej., FP16), opcionalmente puedes cuantizarlo durante la creación (ver abajo).

Aplicando Adaptadores LoRA Safetensors vía Modelfile de Ollama:

Primero, asegúrate de tener el modelo Ollama base exacto en el que se entrenó el adaptador LoRA. Descárgalo si es necesario (ej., ollama pull llama3.2:8b).
Coloca los archivos del adaptador LoRA (ej., adapter_model.safetensors, adapter_config.json) en su propio directorio (ej., /data/adapters/mi_llama3_lora/).
Crea un Modelfile especificando tanto la base como el adaptador:

# ApplyLora.modelfile
FROM llama3.2:8b # ¡Debe coincidir con la base del adaptador!

ADAPTER /data/adapters/mi_llama3_lora/

# Ajusta parámetros o plantilla si el LoRA lo requiere
PARAMETER temperature 0.5
SYSTEM "Ahora respondes en el estilo enseñado por el LoRA."

Construye el modelo adaptado: ollama create llama3-con-mi-lora -f ApplyLora.modelfile.

Cuantizando Modelos con Ollama

La cuantización es el proceso de reducir la precisión numérica de los pesos de un modelo (ej., convertir números de punto flotante de 16 bits a enteros de 4 bits). Esto reduce significativamente el tamaño del archivo del modelo y el uso de memoria (uso de RAM/VRAM) y acelera la inferencia, haciendo posible ejecutar modelos más grandes y capaces en hardware de consumo. La contrapartida suele ser una reducción pequeña, a menudo imperceptible, en la calidad de la salida.

Ollama puede realizar la cuantización durante el proceso de creación del modelo si la instrucción FROM en tu Modelfile apunta a pesos de modelo no cuantizados o de mayor precisión (típicamente Safetensors FP16 o FP32).

Cómo Cuantizar usando ollama create:

Crea un Modelfile que apunte al directorio que contiene los pesos del modelo no cuantizado:

# QuantizeMe.modelfile
FROM /ruta/a/mi/modelo_fp16_no_cuantizado/
# Añade TEMPLATE, PARAMETER, SYSTEM según sea necesario

Ejecuta el comando ollama create, añadiendo la bandera -q (o --quantize) seguida del identificador de nivel de cuantización deseado:

# Cuantizar a Q4_K_M (equilibrio popular de tamaño/calidad)
ollama create mi-modelo-cuantizado-q4km -f QuantizeMe.modelfile -q q4_K_M

# Cuantizar a Q5_K_M (ligeramente más grande, potencialmente mejor calidad)
ollama create mi-modelo-cuantizado-q5km -f QuantizeMe.modelfile -q q5_K_M

# Cuantizar a Q8_0 (cuantización común más grande, mejor calidad entre cuantizados)
ollama create mi-modelo-cuantizado-q8 -f QuantizeMe.modelfile -q q8_0

# Cuantizar a Q3_K_S (muy pequeño, más pérdida de calidad)
ollama create mi-modelo-cuantizado-q3ks -f QuantizeMe.modelfile -q q3_K_S

Ollama utiliza las rutinas de cuantización de llama.cpp para realizar la conversión y guarda el modelo recién cuantizado con el nombre especificado.

Niveles de Cuantización Comunes:

q4_0, q4_1: Cuantización básica de 4 bits.
q5_0, q5_1: Cuantización básica de 5 bits.
q8_0: Cuantización de 8 bits (tamaño de archivo más grande, más cercano a la calidad original).
q3_K_S, q3_K_M, q3_K_L: Métodos "K-Quant" de 3 bits más avanzados (variaciones internas Pequeño/Mediano/Grande). Muy pequeño, notable pérdida de calidad.
q4_K_S, q4_K_M: K-Quants avanzados de 4 bits. q4_K_M suele ser un punto óptimo recomendado.
q5_K_S, q5_K_M: K-Quants avanzados de 5 bits. Buen equilibrio, ligeramente más grande que Q4_K.
q6_K: K-Quant avanzado de 6 bits. Tamaño más grande, acercándose a la calidad Q8.

Elegir el nivel de cuantización correcto depende de las restricciones de tu hardware y tu tolerancia a la posible reducción de calidad. A menudo vale la pena probar q4_K_M o q5_K_M primero.

Compartiendo tus Modelos Personalizados de Ollama

Si has creado una variante de modelo única usando un Modelfile – quizás aplicando un LoRA específico, estableciendo un prompt de sistema y plantilla creativos, o ajustando parámetros – puedes compartir tu creación con la comunidad Ollama más amplia a través del sitio web oficial del registro de modelos de Ollama.

Pasos para Compartir un Modelo Ollama:

Crear una Cuenta Ollama: Regístrate para obtener una cuenta gratuita en el sitio web de Ollama (ollama.com). Tu nombre de usuario elegido se convertirá en el espacio de nombres para tus modelos compartidos.
Vincular tu Ollama Local: Necesitas asociar tu instalación local de Ollama con tu cuenta en línea. Esto implica añadir la clave pública de Ollama de tu máquina local a la configuración de tu cuenta en el sitio web. El sitio web proporciona instrucciones específicas sobre cómo encontrar tu archivo de clave pública local (id_ed25519.pub) según tu sistema operativo.
Nombrar tu Modelo Correctamente: Los modelos compartidos deben tener un espacio de nombres con tu nombre de usuario de Ollama, siguiendo el formato tu_nombre_usuario/tu_nombre_modelo. Si tu modelo personalizado local tiene un nombre diferente (ej., mario), primero necesitas copiarlo al nombre con espacio de nombres correcto usando ollama cp:

# Asumiendo que tu nombre de usuario es 'luigi' y el modelo local es 'mario'
ollama cp mario luigi/mario

Subir el Modelo al Registro: Una vez que el modelo esté correctamente nombrado localmente y tu clave esté vinculada, usa el comando ollama push:

ollama push luigi/mario

Ollama subirá las capas de modelo y metadatos necesarios al registro.

Después de que la subida se complete, otros usuarios de Ollama en todo el mundo pueden descargar y ejecutar fácilmente tu modelo compartido simplemente usando su nombre con espacio de nombres:

ollama run luigi/mario

Este mecanismo de compartición fomenta la colaboración y permite a la comunidad beneficiarse de modelos especializados o personalizados creativamente.

Optimizando el Rendimiento de Ollama con Aceleración GPU

Aunque Ollama puede ejecutar modelos puramente en la CPU de tu computadora, aprovechar una Unidad de Procesamiento Gráfico (GPU) compatible proporciona un impulso de rendimiento drástico, acelerando significativamente la velocidad a la que los modelos generan texto (velocidad de inferencia). Ollama está diseñado para detectar y utilizar automáticamente las GPU compatibles siempre que sea posible.

Ollama con GPUs NVIDIA: Ollama ofrece un excelente soporte para GPUs NVIDIA, requiriendo:

Una GPU con Capacidad de Cómputo CUDA 5.0 o superior (la mayoría de las tarjetas GeForce GTX 900 series / Quadro M series y posteriores). Verifica la lista de GPUs CUDA de NVIDIA para compatibilidad.
Los controladores propietarios oficiales de NVIDIA instalados correctamente en tu sistema host (Linux o Windows).
En Linux con Docker, el NVIDIA Container Toolkit debe estar instalado y configurado.
Ollama debería detectar automáticamente hardware y controladores compatibles y descargar la computación a la GPU.

Ollama con GPUs AMD Radeon: El soporte para GPUs AMD modernas está disponible tanto en Windows como en Linux:

Requiere controladores AMD Radeon Software (Adrenalin Edition) recientes en Windows.
Requiere la pila de software ROCm (Radeon Open Compute platform) instalada en Linux (se recomienda la versión 5 o 6+). El instalador de Ollama para Linux o la imagen Docker :rocm a menudo ayudan con las dependencias, pero puede ser necesaria la instalación manual de ROCm para una compatibilidad total en ciertas distribuciones.
Las GPUs compatibles generalmente incluyen las series RX 6000, RX 7000, PRO W6000/W7000 y algunos aceleradores Instinct. Consulta la documentación oficial de GPU de Ollama para obtener una lista detallada.

Ollama con Apple Silicon (macOS): En Macs equipados con chips de la serie M1, M2, M3 o M4, Ollama utiliza automáticamente las capacidades de GPU incorporadas a través de la API gráfica Metal de Apple. Normalmente no se requiere instalación de controladores o configuración adicional; la aceleración de GPU funciona de inmediato.

Verificando el Uso de GPU de Ollama:
La forma más fácil de verificar si Ollama está usando realmente tu GPU es ejecutar el comando ollama ps mientras un modelo está cargado (ej., inmediatamente después de iniciar ollama run <modelo> en otra terminal, o mientras se procesa una solicitud API). Examina la columna PROCESSOR en la salida:

gpu: Indica que las capas del modelo están cargadas principalmente en la GPU.
cpu: Indica que el modelo se está ejecutando únicamente en la CPU. Esto podría significar que no se detectó ninguna GPU compatible, que faltan controladores o son incorrectos, o que hubo un problema al inicializar el soporte de GPU. Verifica los registros del servidor Ollama en busca de errores.

Seleccionando GPUs Específicas en Configuraciones Multi-GPU de Ollama:
Si tu sistema contiene múltiples GPUs compatibles, puedes indicar a Ollama (y al llama.cpp subyacente) qué dispositivo(s) específico(s) usar estableciendo variables de entorno antes de iniciar el proceso del servidor/aplicación Ollama:

NVIDIA (CUDA_VISIBLE_DEVICES): Establece esta variable a una lista separada por comas de índices de GPU (comenzando desde 0) o, preferiblemente, UUIDs de GPU.
export CUDA_VISIBLE_DEVICES=0 (Usa solo la primera GPU detectada por NVIDIA).
export CUDA_VISIBLE_DEVICES=1 (Usa solo la segunda GPU).
export CUDA_VISIBLE_DEVICES=GPU-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx,GPU-yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy (Usa GPUs específicas identificadas por sus UUIDs, que puedes encontrar usando nvidia-smi -L).
AMD (ROCR_VISIBLE_DEVICES): Establece esta variable a una lista separada por comas de índices de GPU según lo informado por el comando rocminfo (generalmente comenzando desde 0).
export ROCR_VISIBLE_DEVICES=0 (Usa la primera GPU AMD detectada).
export ROCR_VISIBLE_DEVICES=1,2 (Usa la segunda y tercera GPU AMD detectadas).

Establecer un ID de dispositivo inválido (ej., export CUDA_VISIBLE_DEVICES=-1) se usa a menudo como una forma de forzar deliberadamente a Ollama a usar solo la CPU, lo cual puede ser útil para depurar. Recuerda reiniciar el servidor/aplicación Ollama después de establecer estas variables de entorno para que surtan efecto.

Configurando tu Entorno Ollama

Más allá de la configuración predeterminada, el comportamiento de Ollama se puede ajustar finamente usando varias variables de entorno. Estas te permiten personalizar la configuración de red, las ubicaciones de almacenamiento, los niveles de registro y más.

Variables de Entorno Clave de Ollama para Configuración

OLLAMA_HOST: Controla la interfaz de red y el puerto en el que escucha el servidor API de Ollama.
Predeterminado: 127.0.0.1:11434 (Escucha solo en la interfaz loopback, accesible solo desde la misma máquina).
Ejemplo: 0.0.0.0:11434 (Escucha en todas las interfaces de red disponibles, haciendo que Ollama sea accesible desde otros dispositivos en tu red local. Advertencia: Asegúrate de que las reglas de firewall adecuadas estén implementadas si expones Ollama externamente).
Ejemplo: 192.168.1.100:11500 (Escucha solo en una dirección IP local específica y un puerto personalizado).
OLLAMA_MODELS: Crucialmente, esta variable te permite especificar una ruta de directorio personalizada donde Ollama debe almacenar y buscar modelos descargados. Esto es extremadamente útil si tu unidad predeterminada (donde reside ~/.ollama o C:\Users\<Usuario>\.ollama) tiene poco espacio o si prefieres organizar modelos en un SSD dedicado o una unidad más grande.
Ejemplo (Linux/macOS): export OLLAMA_MODELS=/mnt/large_drive/my_ollama_models
Ejemplo (Windows): Establece OLLAMA_MODELS en D:\OllamaData a través de Propiedades del Sistema.
Importante: Asegúrate de que el directorio exista y que la cuenta de usuario que ejecuta el proceso del servidor Ollama tenga permisos completos de lectura y escritura para esta ruta personalizada.
OLLAMA_ORIGINS: Gestiona el Intercambio de Recursos de Origen Cruzado (CORS) para la API de Ollama. Por defecto, los navegadores web restringen que las páginas web realicen solicitudes API a dominios (orígenes) diferentes de aquel desde el que se sirvió la página. Si estás ejecutando una interfaz de usuario web separada (como Open WebUI, Lobe Chat) servida desde un origen diferente (ej., http://localhost:3000) que necesita llamar a tu API de Ollama (en http://localhost:11434), debes agregar el origen de la UI a esta variable.
Ejemplo: export OLLAMA_ORIGINS=http://localhost:3000,http://192.168.1.50:8080 (Permite solicitudes desde estos dos orígenes específicos).
Ejemplo: export OLLAMA_ORIGINS='*' (Permite solicitudes desde cualquier origen. Úsalo con precaución, especialmente si OLLAMA_HOST no es 127.0.0.1, ya que esto podría exponer ampliamente tu API). Puede incluir protocolos como chrome-extension://*.
OLLAMA_DEBUG: Establécelo en 1 para habilitar el registro de depuración detallado. Esto proporciona información mucho más detallada sobre las operaciones internas de Ollama, incluidos los pasos de detección de GPU, detalles de carga de modelos y posibles errores, lo cual es invaluable para la solución de problemas.
Ejemplo: export OLLAMA_DEBUG=1
OLLAMA_KEEP_ALIVE: Controla cuánto tiempo Ollama mantiene un modelo cargado en memoria después de su última solicitud. Por defecto, podría ser alrededor de 5 minutos (5m). Establecerlo en 0 descarga el modelo inmediatamente después de su uso (ahorra RAM/VRAM pero aumenta el tiempo de carga para la siguiente solicitud). Establecerlo en una duración más larga (ej., 30m) o -1 (lo mantiene cargado indefinidamente hasta que se detenga el servidor) puede acelerar las solicitudes frecuentes al mismo modelo pero consume recursos constantemente.
Ejemplo: export OLLAMA_KEEP_ALIVE=15m
HTTPS_PROXY / HTTP_PROXY / NO_PROXY: Variables de entorno de red estándar utilizadas si Ollama necesita enrutar sus solicitudes de internet salientes (ej., al ejecutar ollama pull para descargar modelos de ollama.com) a través de un servidor proxy, común en entornos corporativos.
Ejemplo: export HTTPS_PROXY=http://proxy.mycompany.com:8080

Métodos para Establecer Variables de Entorno de Ollama

La forma correcta de establecer estas variables depende de cómo instalaste y ejecutas Ollama:

Ollama en macOS (Usando la App): Las variables de entorno para aplicaciones GUI en macOS se establecen mejor usando launchctl. Abre Terminal y usa:

launchctl setenv OLLAMA_MODELS "/Volumes/ExternalSSD/OllamaStorage"
launchctl setenv OLLAMA_HOST "0.0.0.0:11434"
# Repite para otras variables

Después de establecer las variables, debes Salir y reiniciar la aplicación Ollama desde el icono de la barra de menú para que los cambios surtan efecto.

Ollama en Linux (Usando Servicio Systemd): El método recomendado es crear un archivo de anulación para el servicio:

Ejecuta sudo systemctl edit ollama.service. Esto abre un editor de texto vacío.
Añade las siguientes líneas, modificando la variable y el valor según sea necesario:

[Service]
Environment="OLLAMA_MODELS=/ruta/a/directorio/modelo/personalizado"
Environment="OLLAMA_HOST=0.0.0.0:11434"
Environment="OLLAMA_DEBUG=1"

Guarda y cierra el editor.
Aplica los cambios: sudo systemctl daemon-reload
Reinicia el servicio Ollama: sudo systemctl restart ollama

Ollama en Windows: Usa el editor de Variables de Entorno incorporado:

Busca "Editar las variables de entorno del sistema" en el menú Inicio y ábrelo.
Haz clic en el botón "Variables de entorno...".
Puedes establecer variables para tu usuario específico ("Variables de usuario") o para todos los usuarios ("Variables del sistema"). Las variables del sistema generalmente requieren privilegios de administrador.
Haz clic en "Nueva..." bajo la sección deseada.
Ingresa el Nombre de variable (ej., OLLAMA_MODELS) y el Valor de variable (ej., D:\OllamaData).
Haz clic en Aceptar en todos los diálogos abiertos.
Crucialmente, debes reiniciar el proceso en segundo plano de Ollama. Abre el Administrador de tareas (Ctrl+Shift+Esc), ve a la pestaña "Servicios", busca "Ollama", haz clic derecho y selecciona "Reiniciar". Alternativamente, reinicia tu computadora.

Ollama vía Docker: Pasa las variables de entorno directamente en el comando docker run usando la bandera -e para cada variable:

docker run -d \
  --gpus=all \
  -v ollama_data:/root/.ollama \
  -p 127.0.0.1:11434:11434 \
  -e OLLAMA_HOST="0.0.0.0:11434" \
  -e OLLAMA_DEBUG="1" \
  -e OLLAMA_KEEP_ALIVE="10m" \
  --name my_ollama_configured \
  ollama/ollama

Ollama vía ollama serve manual en Terminal: Simplemente antepón al comando las asignaciones de variables en la misma línea:

OLLAMA_DEBUG=1 OLLAMA_HOST=0.0.0.0:11434 OLLAMA_MODELS=/data/ollama ollama serve

Estas variables solo se aplicarán a esa instancia específica del servidor.

Elige el método apropiado para tu configuración y recuerda reiniciar el proceso del servidor Ollama después de realizar cambios para que se activen.

Solución de Problemas Comunes de Ollama

Incluso con el enfoque de Ollama en la simplicidad, podrías encontrar contratiempos ocasionales. Aquí te mostramos cómo diagnosticar y resolver algunos problemas frecuentes:

Consultando los Registros de Ollama

Tu principal herramienta de diagnóstico es el archivo de registro del servidor Ollama. Registra información de inicio, intentos de carga de modelos, resultados de detección de GPU, solicitudes API y, lo más importante, mensajes de error detallados.

Ubicaciones Predeterminadas del Archivo de Registro:

Ollama en macOS: ~/.ollama/logs/server.log
Ollama en Linux (Systemd): Usa el comando de control de journal: journalctl -u ollama. Añade -f para seguir los registros en tiempo real (journalctl -u ollama -f). Usa -n 100 para ver las últimas 100 líneas (journalctl -u ollama -n 100).
Ollama en Windows: El archivo de registro es server.log ubicado dentro de %LOCALAPPDATA%\Ollama. Puedes abrir fácilmente esta carpeta pegando %LOCALAPPDATA%\Ollama en la barra de direcciones del Explorador de archivos o en el diálogo Ejecutar (Win+R).
Ollama vía Docker: Usa el comando de registros de Docker: docker logs my_ollama (reemplaza my_ollama con el nombre de tu contenedor). Añade -f para seguir (docker logs -f my_ollama).
Ollama vía ollama serve manual: Los registros se imprimen directamente en la ventana de terminal donde lanzaste el comando.

Consejo: Para una solución de problemas más detallada, siempre habilita el registro de depuración estableciendo la variable de entorno OLLAMA_DEBUG=1 antes de iniciar el servidor Ollama, luego verifica los registros nuevamente.

Arreglando el Error de Ollama: `listen tcp 127.0.0.1:11434: bind: address already in use`

Este mensaje de error específico es uno de los problemas más comunes que encuentran los nuevos usuarios. Significa que Ollama no puede iniciar su servidor API porque otro proceso ya está ocupando el puerto de red (predeterminado 11434) que Ollama necesita para escuchar.

Causa Probable:
Otra instancia del servidor Ollama ya se está ejecutando en segundo plano (quizás de una sesión anterior que no se cerró limpiamente).
Una aplicación completamente diferente en tu sistema está usando casualmente el puerto 11434.
Solución 1: Identificar y Detener el Proceso en Conflicto: Necesitas averiguar qué proceso está usando el puerto y detenerlo (si es seguro hacerlo).
Linux / macOS: Abre una terminal y ejecuta sudo lsof -i :11434 o sudo netstat -tulnp | grep 11434. Estos comandos deberían mostrar el ID de Proceso (PID) del programa que usa el puerto. Luego puedes intentar detenerlo elegantemente o usar sudo kill <PID>. Si es un proceso antiguo de Ollama, matarlo debería resolver el conflicto.
Windows: Abre el Símbolo del sistema como Administrador y ejecuta netstat -ano | findstr "11434". Mira la última columna para el PID. Abre el Administrador de tareas (Ctrl+Shift+Esc), ve a la pestaña "Detalles" (o "Procesos" y añade la columna PID), busca el proceso con ese PID y finalízalo si es apropiado.
Solución 2: Cambiar el Puerto de Escucha de Ollama: Si no puedes detener el proceso en conflicto, o si intencionalmente quieres que Ollama se ejecute en un puerto diferente, puedes configurar Ollama para usar un puerto alternativo. Establece la variable de entorno OLLAMA_HOST para incluir tu puerto deseado antes de iniciar Ollama.
Ejemplo: Establece OLLAMA_HOST en 127.0.0.1:11435 (usando los métodos descritos en la sección de Configuración).
Recuerda ajustar cualquier configuración de cliente API, interfaces de usuario web o scripts para apuntar al nuevo puerto (ej., http://localhost:11435) después de realizar este cambio.

Resolviendo Problemas de Detección y Uso de GPU de Ollama

Si ollama ps muestra cpu en lugar de gpu, o si encuentras errores específicos relacionados con la GPU en los registros (como CUDA error, ROCm error), sigue estos pasos:

Confirmar Compatibilidad de GPU: Verifica nuevamente que tu modelo de GPU específico esté listado como compatible en la documentación oficial de GPU de Ollama en GitHub.
Actualizar Controladores: Asegúrate de tener instalados correctamente los últimos controladores oficiales estables directamente desde los sitios web de NVIDIA o AMD. Los controladores genéricos incluidos con el SO a menudo son insuficientes. Se recomienda encarecidamente un reinicio completo del sistema después de la instalación del controlador.
Verificar Registros de Ollama (Modo Debug): Establece OLLAMA_DEBUG=1, reinicia el servidor Ollama y examina cuidadosamente los registros de inicio. Busca mensajes relacionados con la detección de GPU, carga de bibliotecas (CUDA, ROCm) y cualquier código de error específico.
Específicos de NVIDIA (Linux):
Verifica que el comando nvidia-smi funcione y muestre tu GPU y la versión del controlador.
Si usas Docker, confirma que el NVIDIA Container Toolkit esté instalado y funcional (docker run --rm --gpus all nvidia/cuda:12.1.0-base-ubuntu22.04 nvidia-smi).
Verifica si los módulos del kernel necesarios están cargados (lsmod | grep nvidia). A veces, recargarlos (sudo rmmod nvidia_uvm nvidia && sudo modprobe nvidia_uvm nvidia) puede ayudar.
Verifica los registros del sistema (dmesg | grep -iE 'nvidia|nvrm') en busca de errores de hardware o controlador.
Específicos de AMD (Linux):
Verifica que el comando rocminfo funcione y muestre tu GPU.
Asegúrate de que el usuario que ejecuta Ollama (o el contenedor Docker) tenga los permisos correctos para los dispositivos /dev/kfd y /dev/dri/renderD* (a menudo requiere membresía en los grupos render y video). Verifica la membresía del grupo con groups $USER o groups ollama. Es posible que necesites --group-add render --group-add video en tu comando Docker.
Verifica los registros del sistema (dmesg | grep -iE 'amdgpu|kfd') en busca de errores.
Forzar CPU (para pruebas): Como paso de diagnóstico temporal, intenta forzar el uso de la CPU estableciendo CUDA_VISIBLE_DEVICES=-1 o ROCR_VISIBLE_DEVICES=-1. Si Ollama se ejecuta correctamente en la CPU, confirma que el problema está relacionado con la configuración de la GPU.

Abordando Otros Problemas Comunes de Ollama

Errores de Permiso (Directorio de Modelos): Especialmente en Linux con el servicio systemd, si Ollama no puede descargar o crear modelos, podría carecer de permisos de escritura para el directorio de almacenamiento de modelos (OLLAMA_MODELS o el predeterminado). Asegúrate de que el directorio exista y sea propiedad o escribible por el usuario/grupo ollama (sudo chown -R ollama:ollama /ruta/a/modelos y sudo chmod -R 775 /ruta/a/modelos).
Descargas Lentas de Modelos (ollama pull):
Verifica la velocidad de tu conexión a internet básica.
Si estás detrás de un proxy, asegúrate de que HTTPS_PROXY esté configurado correctamente.
Verifica si hay reglas de firewall que potencialmente bloqueen o limiten las conexiones a ollama.com.
En Windows con WSL2, el conocido problema LSO (Large Send Offload) a veces puede afectar el rendimiento de la red dentro de WSL. Deshabilitar LSOv2 para el adaptador de red virtual WSL en la configuración del Adaptador de Red de Windows podría ayudar, aunque esto es menos común ahora.
Salida de Terminal Confusa (ollama run en Windows antiguos): Si ves caracteres extraños como ←[?25h... en cmd.exe o PowerShell en versiones antiguas de Windows 10, probablemente se deba a un soporte deficiente de códigos de escape ANSI. Las mejores soluciones son:
Actualizar Windows 10 a la versión 22H2 o posterior.
Usar Windows 11.
Usar la aplicación moderna Terminal de Windows, que tiene un excelente soporte ANSI.

Si has agotado estos pasos de solución de problemas y has revisado los registros de depuración sin éxito, la comunidad de Ollama es un gran recurso. Prepara una descripción clara del problema, incluye detalles relevantes sobre tu SO, versión de Ollama, hardware (CPU/GPU/RAM), el modelo específico que estás usando, el comando que ejecutaste y, crucialmente, las secciones relevantes de tus registros de depuración. Publica tu pregunta en el Discord de Ollama o presenta un issue bien documentado en el repositorio de GitHub de Ollama.

Cómo desinstalar Ollama completamente

Si necesitas eliminar Ollama de tu sistema, el proceso varía según tu método de instalación inicial. Típicamente implica eliminar la aplicación/binario, el servicio en segundo plano (si aplica) y los archivos de modelos/configuración almacenados.

Desinstalando Ollama en macOS (Instalado vía .app):

Salir de Ollama: Haz clic en el icono de Ollama en la barra de menú y selecciona "Salir de Ollama".
Eliminar Aplicación: Arrastra Ollama.app desde tu carpeta /Aplicaciones a la Papelera/Bin.
Eliminar Datos y Configuración: Abre Terminal y ejecuta rm -rf ~/.ollama. Advertencia: Esto elimina permanentemente todos los modelos descargados y la configuración. Verifica dos veces el comando antes de ejecutarlo.
(Opcional) Desestablecer Variables de Entorno: Si estableciste variables manualmente usando launchctl setenv, puedes desestablecerlas: launchctl unsetenv OLLAMA_HOST, launchctl unsetenv OLLAMA_MODELS, etc.

Desinstalando Ollama en Windows (Instalado vía .exe):

Usar Desinstalador de Windows: Ve a "Configuración" > "Aplicaciones" > "Aplicaciones instaladas". Localiza "Ollama" en la lista, haz clic en los tres puntos (...) junto a él y selecciona "Desinstalar". Sigue las indicaciones de desinstalación.
Eliminar Datos y Configuración: Después de que finalice el desinstalador, elimina manualmente el directorio de datos de Ollama. Abre el Explorador de archivos, escribe %USERPROFILE%\.ollama en la barra de direcciones, presiona Enter y elimina toda la carpeta .ollama. Advertencia: Esto elimina todos los modelos.
(Opcional) Eliminar Variables de Entorno: Si añadiste manualmente OLLAMA_HOST, OLLAMA_MODELS, etc., a través de Propiedades del Sistema, vuelve allí ("Editar las variables de entorno del sistema") y elimínalas.

Desinstalando Ollama en Linux (Instalado vía Script o Binario Manual):

Detener el Servicio: sudo systemctl stop ollama
Deshabilitar el Servicio: sudo systemctl disable ollama
Eliminar Binario: sudo rm /usr/local/bin/ollama (o la ruta donde lo instalaste).
Eliminar Archivo de Servicio: sudo rm /etc/systemd/system/ollama.service
Recargar Systemd: sudo systemctl daemon-reload
(Opcional) Eliminar Usuario/Grupo: Si se crearon el usuario/grupo ollama: sudo userdel ollama, sudo groupdel ollama.
Eliminar Datos y Configuración: Elimina el directorio de almacenamiento de modelos. Esto depende de dónde se almacenó:

Si se ejecutó como tu usuario: rm -rf ~/.ollama
Si se ejecutó como servicio del sistema (usuario ollama): sudo rm -rf /usr/share/ollama/.ollama (o la ruta especificada por OLLAMA_MODELS en el archivo de servicio).
Advertencia: Usa sudo rm -rf con extrema precaución. Verifica que la ruta sea correcta antes de ejecutar.

Desinstalando Ollama vía Docker:

Detener el Contenedor: docker stop my_ollama (usa el nombre de tu contenedor).
Eliminar el Contenedor: docker rm my_ollama.
Eliminar la Imagen: docker rmi ollama/ollama (y ollama/ollama:rocm si lo usaste).
(Opcional, Destructivo) Eliminar el Volumen: Si quieres eliminar todos los modelos descargados almacenados en el volumen Docker, ejecuta docker volume rm ollama_data (usa el nombre del volumen que creaste). Advertencia: Esto es irreversible.

Conclusión: Abrazando el Poder de la IA Local con Ollama

Ollama se erige como una herramienta fundamental para democratizar el acceso al inmenso poder de los modernos Grandes Modelos de Lenguaje. Al abstraer elegantemente las complejidades de la configuración, ajuste y ejecución, empodera a una diversa gama de usuarios – desde desarrolladores e investigadores experimentados hasta entusiastas curiosos – para ejecutar IA sofisticada directamente en su propio hardware. Las ventajas son claras: privacidad incomparable, liberación de los costos recurrentes de API, operación fiable sin conexión y la capacidad liberadora de personalizar y experimentar profundamente con modelos usando el intuitivo sistema Modelfile y la robusta API.

Ya sea que tu objetivo sea construir la próxima generación de aplicaciones impulsadas por IA, realizar investigaciones de vanguardia manteniendo la soberanía de los datos, o simplemente explorar las fascinantes capacidades de la generación de lenguaje sin dependencias externas, Ollama proporciona una base estable, eficiente y fácil de usar. Logra cerrar con éxito la brecha entre la potencia bruta de motores de inferencia como llama.cpp y las necesidades prácticas de los usuarios, fomentando la innovación dentro del vibrante panorama de la IA de código abierto.

El viaje al mundo de los LLMs locales es accesible y profundamente gratificante, gracias a Ollama. Descarga la aplicación, obtén tu primer modelo usando ollama pull, inicia una conversación con ollama run y comienza a desbloquear el vasto potencial de la inteligencia artificial, directamente en tu propia máquina.

💡