Blog
Punto de vista

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

Audrey Lopez

Audrey Lopez

28 April 2025

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?

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.

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:

Instalando Ollama en macOS

  1. Descargar: Obtén el archivo DMG de la aplicación Ollama para macOS directamente desde el sitio web oficial de Ollama.
  2. Montar: Haz doble clic en el archivo .dmg descargado para abrirlo.
  3. Instalar: Arrastra el icono Ollama.app a tu carpeta de Aplicaciones.
  4. Ejecutar: Abre la aplicación Ollama desde tu carpeta de Aplicaciones. Es posible que necesites concederle permiso para ejecutarse la primera vez.
  5. 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

  1. Descargar: Obtén el archivo instalador OllamaSetup.exe del sitio web de Ollama.
  2. 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).
  3. 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:

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:

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:

  1. Descargar el binario correcto para tu arquitectura.
  2. Hacer el binario ejecutable (chmod +x ollama) y moverlo a una ubicación en tu PATH (ej., /usr/local/bin).
  3. (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.
  4. 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.
  5. Recargar el demonio systemd: sudo systemctl daemon-reload.
  6. Habilitar el servicio para que se inicie en el arranque: sudo systemctl enable ollama.
  7. 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:

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

Contenedor Ollama con GPU NVIDIA:

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

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

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:

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:

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

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:

Recomendaciones para Principiantes (Finales de 2024):

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:

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.

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:

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:

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:

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:

  1. base_url (o api_base): Establécelo a tu punto final local de Ollama v1: http://localhost:11434/v1/.
  2. 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:

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>.

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.

  1. Descarga el archivo .gguf (ej., zephyr-7b-beta.Q5_K_M.gguf).
  2. 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
  1. 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:

  1. 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/).
  2. 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
  1. 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:

  1. 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).
  2. Coloca los archivos del adaptador LoRA (ej., adapter_model.safetensors, adapter_config.json) en su propio directorio (ej., /data/adapters/mi_llama3_lora/).
  3. 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."
  1. 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:

  1. 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
  1. 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:

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:

  1. 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.
  2. 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.
  3. 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
  1. 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:

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

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:

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:

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

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:

  1. Ejecuta sudo systemctl edit ollama.service. Esto abre un editor de texto vacío.
  2. 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"
  1. Guarda y cierra el editor.
  2. Aplica los cambios: sudo systemctl daemon-reload
  3. Reinicia el servicio Ollama: sudo systemctl restart ollama

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

  1. Busca "Editar las variables de entorno del sistema" en el menú Inicio y ábrelo.
  2. Haz clic en el botón "Variables de entorno...".
  3. 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.
  4. Haz clic en "Nueva..." bajo la sección deseada.
  5. Ingresa el Nombre de variable (ej., OLLAMA_MODELS) y el Valor de variable (ej., D:\OllamaData).
  6. Haz clic en Aceptar en todos los diálogos abiertos.
  7. 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:

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.

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:

Abordando Otros Problemas Comunes de Ollama

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

  1. Salir de Ollama: Haz clic en el icono de Ollama en la barra de menú y selecciona "Salir de Ollama".
  2. Eliminar Aplicación: Arrastra Ollama.app desde tu carpeta /Aplicaciones a la Papelera/Bin.
  3. 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.
  4. (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):

  1. 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.
  2. 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.
  3. (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):

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

Desinstalando Ollama vía Docker:

  1. Detener el Contenedor: docker stop my_ollama (usa el nombre de tu contenedor).
  2. Eliminar el Contenedor: docker rm my_ollama.
  3. Eliminar la Imagen: docker rmi ollama/ollama (y ollama/ollama:rocm si lo usaste).
  4. (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.

💡
¿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

Explore more

¿Dónde Descargar Swagger UI en Español Gratis?

¿Dónde Descargar Swagger UI en Español Gratis?

¿Necesitas Swagger UI en español? Este artículo explica por qué no existe una descarga oficial gratuita y cómo habilitar la traducción. Explora las características de Swagger y por qué Apidog es la alternativa superior para diseño, pruebas y documentación API integrados.

23 April 2025

¿Dónde Descargar Postman en Español Gratis?

¿Dónde Descargar Postman en Español Gratis?

¿Puedes descargar Postman en español gratis? Aunque Postman carece de soporte nativo en español, existen soluciones. Explóralas y descubre Apidog, una potente alternativa unificada a Postman diseñada para optimizar todo tu flujo de trabajo de API, sin importar el idioma.

22 April 2025

Cómo usar GPT-4.1 con Cursor

Cómo usar GPT-4.1 con Cursor

Esta guía explica el rendimiento de GPT-4.1, precios y dos métodos para integrarlo en Cursor.

15 April 2025

Practica el diseño de API en Apidog

Descubre una forma más fácil de construir y usar APIs

Registrarse gratisDescargar