“Hola, mundo” en Ollama

El 'Hola, mundo' de Ollama: ejecutar un modelo LLaMA2 con Ollama desde tu terminal, descargar los archivos si no los tienes y luego iniciar una sesión interactiva para generar una respuesta a un prompt.

📋 Copiar

# 1. Instala Ollama desde ollama.com/download
# 2. Abre tu terminal y ejecuta:
ollama run llama2
# La primera vez descargara el modelo. Luego podras escribir tu prompt.

Resultado:

Output

Ollama descargará el modelo 'llama2' (si no lo tienes), lo cargará y te presentará un prompt `>>>`. Escribe tu pregunta y el modelo generará una respuesta directamente en tu terminal.

Comandos básicos

Familiarizarse con estos comandos es esencial para interactuar eficientemente con Ollama:

Instalar Ollama en tu sistema operativo
📋 Copiar
```
Visita https://ollama.com/download. Descarga y ejecuta el instalador para macOS, Windows o usa el script de instalación para Linux:
`curl -fsSL https://ollama.com/install.sh | sh`
```
Los pasos para instalar Ollama varían según tu sistema operativo. Sigue las instrucciones de la página oficial para una instalación correcta.
Ejecutar un modelo (descarga si no existe y ejecuta interactivamente)
📋 Copiar
```
ollama run <nombre_modelo>
```
Comando principal. Busca el modelo por nombre (ej: `llama2`, `mistral`, `gemma`). Si no lo tienes descargado, lo descarga primero. Luego inicia una sesión de chat interactiva en la terminal con ese modelo.
Ver modelos descargados localmente
📋 Copiar
```
ollama list
```
Muestra una lista de todos los modelos de lenguaje que tienes descargados y almacenados en tu máquina local, incluyendo su tamaño y fecha de modificación.
Descargar un modelo específico por tag (sin ejecutar)
📋 Copiar
```
ollama pull <nombre_modelo>:<tag>
```
Descarga los archivos de un modelo específico con un 'tag' determinado (ej: `llama2:13b`, `mistral:7b-instruct`, `gemma:2b-instruct-q4_0`) desde el Ollama Library. Útil para obtener versiones o cuantizaciones concretas sin iniciar una sesión interactiva.
Ejecutar Ollama como servidor (en background)
📋 Copiar
```
ollama serve
```
Inicia el demonio o servicio de Ollama en segundo plano. Esto es necesario para que la API HTTP local (por defecto en `http://localhost:11434`) esté activa y puedas interactuar con los modelos desde otras aplicaciones o scripts.

Crear un modelo personalizado usando un 'ModelFile'

📋 Copiar

1. Crea un archivo de texto (ej: `mi_robot.Modelfile`).
2. Define el modelo base y configuraciones (ver docs para sintaxis de Modelfile).
```
FROM llama2:7b-chat
PARAMETER temperature 0.5
SYSTEM "Eres un robot con voz monotona y siempre respondes con datos cientificos."
```
3. Ejecuta el comando `ollama create mi_robot -f ./mi_robot.Modelfile`

Permite crear un nuevo modelo local con un nombre propio, basado en un modelo existente. Puedes ajustar parámetros por defecto para la inferencia, añadir un prompt de sistema constante o añadir contexto/conocimiento inicial.

Ejecutar un modelo personalizado
📋 Copiar
```
ollama run <nombre_de_tu_modelo_personalizado>
```
Inicia una sesión interactiva en la terminal o lo ejecuta para recibir prompts desde la API, utilizando las configuraciones definidas en el ModelFile con el que fue creado.
Interactuar con un modelo vía API local (ej: con curl - generate)
📋 Copiar
```
curl http://localhost:11434/api/generate -d '{"model": "mistral", "prompt": "Describe en una frase la IA.", "stream": false}'
```
Envía un prompt a la API HTTP local de Ollama para obtener una respuesta generada. La opción `"stream": false` es para recibir la respuesta completa al final, `"stream": true` (por defecto) para recibirla token a token.
Interactuar con un modelo vía API local (ej: con curl - chat)
📋 Copiar
```
curl http://localhost:11434/api/chat -d '{"model": "llama2", "messages": [{"role": "user", "content": "Dime un chiste."}] , "stream": false}'
```
Utiliza el endpoint de chat para enviar un historial de mensajes (con roles `system`, `user`, `assistant`) y mantener una conversación estructurada con el modelo vía API. Es compatible con el formato de la API de OpenAI.

Interactuar con un modelo vía API local (ej: con Python requests)

📋 Copiar

import requests

url = "http://localhost:11434/api/chat"
data = {
    "model": "gemma:2b",
    "messages": [
        {"role": "user", "content": "Cuentame algo fascinante sobre el universo."}
    ]
}
response = requests.post(url, json=data)

# Procesar respuesta (la estructura depende del endpoint y stream)
if response.status_code == 200:
    print(response.json()['message']['content'])
else:
    print(f"Error en la API: {response.status_code} - {response.text}")

Envía una petición de chat a la API local de Ollama utilizando la librería `requests` en Python. Puedes usar `http://localhost:11434/api/generate` para generación simple.

Eliminar un modelo local
📋 Copiar
```
ollama rm <nombre_modelo>
```
Borra permanentemente los archivos binarios de un modelo descargado de tu máquina local para liberar espacio en disco.
Mostrar información detallada de un modelo local
📋 Copiar
```
ollama show <nombre_modelo>
```
Proporciona información sobre un modelo local, incluyendo su ID, tamaño en disco, tags, familia de modelos, arquitectura y, opcionalmente (`ollama show <nombre_modelo> --modelfile`), la configuración base o personalizada del Modelfile.
Copiar o renombrar un modelo local
📋 Copiar
```
ollama copy <modelo_existente> <nuevo_nombre_o_tag>
```
Crea una copia de un modelo que ya tienes descargado localmente, asignándole un nuevo nombre o tag. Útil para crear versiones antes de modificarlas con ModelFiles.
Empaquetar un modelo personalizado para compartir
📋 Copiar
```
ollama push <nombre_de_tu_modelo_personalizado>
```
Prepara un modelo que has creado localmente con `ollama create` para ser subido a un registro remoto (si tienes uno configurado) o para ser compartido con otros usuarios de Ollama.

Conceptos Clave

Comprender estos conceptos fundamentales te ayudará a dominar Ollama de forma más organizada y eficiente:

Servidor LLM Local:

Ollama es una aplicación que se instala en tu ordenador y actúa como un servidor para Modelos de Lenguaje Grande (LLMs). Gestiona la descarga, almacenamiento y ejecución de los modelos localmente. Esto permite interactuar con la IA directamente desde tu máquina, sin necesidad de enviar prompts a servicios en la nube.
Ollama CLI (Command-Line Interface):

La herramienta principal para interactuar con Ollama desde la terminal de tu sistema operativo. Proporciona comandos sencillos para descargar modelos (`pull`), listar modelos (`list`), ejecutar modelos de forma interactiva (`run`), crear modelos personalizados (`create`), eliminar modelos (`rm`), etc.
Ollama API (HTTP):

Cuando el servicio de Ollama está corriendo (`ollama serve`), expone una API RESTful en `http://localhost:11434` (por defecto). Esta API permite que otras aplicaciones, scripts o frameworks de desarrollo (escritos en Python, JavaScript, etc.) se conecten a Ollma y utilicen los modelos programáticamente para generación de texto, chat, embeddings, etc.
Ollama Library (ollama.com/library):

Un catálogo en línea de modelos de lenguaje populares (como LLaMA, Mistral, Gemma, Phi-2, Neural Behemoth, etc.) que han sido adaptados y optimizados para funcionar con Ollama. Puedes explorar la biblioteca para encontrar modelos que se ajusten a tus necesidades y hardware, y descargarlos fácilmente con `ollama pull`.
Model Files:

Archivos de texto simples que te permiten personalizar modelos en Ollama. Utilizan una sintaxis inspirada en Dockerfiles. Puedes especificar el modelo base (`FROM`), ajustar parámetros de inferencia por defecto (`PARAMETER`), añadir un prompt de sistema (`SYSTEM`), incluir datos adicionales para RAG o definir la estructura de conversaciones. Se usan con `ollama create`.
Formato GGUF:

Los modelos en el Ollama Library y los que descargas localmente suelen estar en formato GGUF (.gguf). Este es un formato binario diseñado para la inferencia de LLMs, optimizado para cargar y ejecutarse eficientemente en CPU y GPU. El formato GGUF soporta cuantización, lo que permite reducir el tamaño del modelo y los requisitos de memoria/VRAM para ejecutar modelos más grandes en hardware limitado.
Gestión de Modelos Local:

Ollama te da control total sobre los modelos que tienes descargados en tu máquina. Puedes ver cuáles tienes (`list`), descargar nuevos (`pull`), eliminar los que no necesitas (`rm`), ver información detallada sobre ellos (`show`), copiar/renombrar (`copy`) y empaquetar tus modelos personalizados para compartir (`push`).
Aceleración por Hardware (GPU y CPU):

Ollama está diseñado para detectar y utilizar automáticamente el hardware de aceleración disponible en tu sistema, principalmente GPUs (Nvidia con CUDA, AMD con ROCm, algunas Intel). Si tienes una GPU compatible, Ollama intentará usarla para acelerar la inferencia. Si no, o si el modelo es demasiado grande para la VRAM, puede usar la CPU o una combinación ('offloading'). La velocidad depende en gran medida de tu hardware.
Model Tags (Tamaño, Cuantización, Versión):

Cada modelo en el Ollama Library puede tener múltiples 'tags' asociados, que especifican diferentes variantes. Los tags comunes indican el tamaño del modelo en parámetros (ej: `:7b`, `:13b`, `:70b`), si es una versión finetuneada para seguir instrucciones/chat (ej: `:instruct`, `:chat`), o el nivel de cuantización (ej: `:q4_0`, `:q5_k_m`, `:fp16`). Elegir el tag correcto es crucial según tu hardware y necesidad de rendimiento/calidad.
API Endpoints (`/api/generate`, `/api/chat`):

La API HTTP local de Ollama tiene diferentes endpoints para distintas tareas. `/api/generate` es el más simple para enviar un prompt y obtener una respuesta de texto. `/api/chat` es el endpoint recomendado para tener conversaciones, ya que permite enviar y recibir historiales de mensajes con roles (compatible con el formato de la API de OpenAI). Otros endpoints permiten gestionar modelos o obtener información del servicio.
Integración con Frameworks LLM (LangChain, LlamaIndex):

Ollama es compatible y se integra fácilmente con frameworks populares de desarrollo de aplicaciones con LLMs. Puedes configurar LangChain o LlamaIndex para utilizar un modelo gestionado por Ollama como tu backend LLM local, permitiendo construir flujos de trabajo complejos (ej: RAG) que se ejecutan localmente.
Privacidad y Uso Offline:

Una de las mayores ventajas de usar Ollama. Como los modelos se ejecutan localmente, los datos de tus prompts nunca salen de tu máquina (a menos que uses un modelo personalizado que acceda a recursos externos que tú configures). Una vez descargado un modelo, puedes interactuar con él sin conexión a internet. Ideal para datos sensibles o para trabajar en entornos sin conectividad fiable.
Facilidad de Uso vs Limitaciones del Hardware Local:

Ollama simplifica enormemente el proceso de empezar a usar LLMs localmente comparado con configurar todo manualmente. Sin embargo, la performance (velocidad y tamaño de los modelos que puedes ejecutar) está directamente limitada por el hardware de tu máquina (CPU, RAM y especialmente VRAM de GPU). Modelos muy grandes (70B+) o cuantizaciones de alta precisión pueden no ser factibles en ordenadores personales.

Casos de uso

Algunos ejemplos de aplicaciones prácticas donde se utiliza Ollama:

Ejecutar LLMs offline en entornos sin conexión a internet o con conectividad limitada:

Utilizar Ollama para proporcionar capacidades de inteligencia artificial en lugares (remotos, viajes, instalaciones con restricciones de red) donde no hay conexión constante a internet. Una vez descargados los modelos, la inferencia ocurre completamente localmente, permitiendo que las aplicaciones funcionen sin conexión.
Procesar datos sensibles o confidenciales utilizando LLMs sin enviar la información a la nube:

Garantizar la privacidad y seguridad de los datos utilizando modelos de lenguaje que se ejecutan localmente en tu máquina con Ollama. Los prompts y las respuestas no salen de tu entorno controlado, lo cual es crucial para datos empresariales, personales o regulados.
Integrar capacidades de LLMs en aplicaciones de escritorio, herramientas internas o intranets corporativas:

Utilizar la API HTTP local de Ollama para añadir funcionalidades de inteligencia artificial (ej: resumen de documentos, asistencia en la escritura, análisis de texto) a software que se ejecuta localmente en los ordenadores de los usuarios o dentro de la red interna de una organización, sin depender de servicios cloud externos.
Crear asistentes de IA altamente personalizados para tareas específicas utilizando ModelFiles:

Definir y entrenar (con ModelFiles que incluyan parámetros, prompts de sistema o incluso RAG básico) modelos para que actúen como expertos en un dominio particular (ej: un asistente para escribir emails legales, un experto en un software específico) o realicen tareas automatizadas en tu máquina, con un comportamiento predecible y adaptado a tus necesidades.
Prototipar y testear rápidamente diferentes LLMs y sus variantes (tamaño, cuantización):

Descargar y probar múltiples modelos desde el Ollama Library (`ollama pull`, `ollama run`) para comparar su rendimiento (velocidad de respuesta) y la calidad de sus respuestas en tu propio hardware. Experimenta con diferentes tamaños de modelo y niveles de cuantización para encontrar el equilibrio adecuado para tu caso de uso y hardware.
Desarrollar y testear pipelines de Retrieval-Augmented Generation (RAG) utilizando modelos locales:

Combinar Ollama con frameworks como LangChain o LlamaIndex para construir sistemas de RAG que permiten a los LLMs acceder y utilizar tu propia base de conocimientos (documentos, bases de datos) para generar respuestas más precisas y contextuales. Como el LLM se ejecuta localmente, puedes mantener tus datos privados.
Utilizar LLMs para scripting, automatización de tareas o procesamiento de texto en tu máquina:

Escribir scripts en Python, Node.js u otros lenguajes que utilicen la API local de Ollama (`http://localhost:11434`) para automatizar tareas como generación de resúmenes de correos, clasificación de texto, extracción de información de documentos o generación de contenido para blogs o redes sociales directamente desde tu máquina.
Aprender y experimentar con diferentes arquitecturas y tipos de LLMs en un entorno controlado y accesible:

Utilizar Ollama para descargar y probar fácilmente una variedad de modelos (basados en diferentes arquitecturas) disponibles en el Ollama Library, observando cómo se comportan, sus fortalezas y debilidades, en tu propio hardware. Es una forma práctica de aprender sobre LLMs.
Construir demos o pruebas de concepto de aplicaciones de IA 'local-first' o 'on-device':

Desarrollar rápidamente prototipos que demuestren los beneficios de ejecutar IA en el dispositivo o localmente, como asistentes de escritura sin conexión, herramientas de análisis de texto privadas, aplicaciones de creatividad visual asistida por IA (si se integra con modelos de visión), etc.

Consejos para Principiantes

Aquí tienes algunas recomendaciones para facilitar tus inicios en Ollama:

Instala Ollama Correctamente y Verifica que el Servicio Esté Corriendo:

Descarga el instalador desde ollama.com/download para tu sistema. Sigue las instrucciones de instalación. Una vez instalado, abre tu terminal y ejecuta `ollama --version` para verificar. El servicio de Ollama (`ollama serve`) suele iniciarse automáticamente en background. Puedes comprobarlo con `ollama list` (debería decir que no hay modelos y sugerir descargar uno).
Domina el Comando Clave: `ollama run <nombre_modelo>`:

Este comando lo hace casi todo. Si el modelo (`llama2`, `mistral`, `gemma`, etc.) no está en tu máquina, lo descargará (esto puede tardar). Luego, iniciará una sesión de chat interactiva en la terminal con ese modelo. ¡Es la forma más rápida de empezar a usar un LLM local!
Explora el 'Ollama Library' en ollama.com/library:

Este es tu catálogo de modelos disponibles para usar con Ollama. Visita el sitio web para ver qué modelos existen, sus descripciones y, lo más importante, sus diferentes 'tags' (versiones, tamaños, cuantizaciones). Haz clic en un modelo para ver sus tags.
Entiende los 'Tags' de Modelos y Prueba Diferentes Tamaños y Cuantizaciones:

Los tags (ej: `:7b`, `:13b`, `:q4_0`, `:instruct`) son cruciales. Modelos más pequeños (`:7b`, `:2b`) o más cuantizados (`:q4_0`) requieren menos RAM/VRAM de GPU y son más rápidos en hardware limitado. Modelos más grandes o con menor cuantización ofrecen más calidad pero necesitan más recursos. Prueba varios para encontrar el equilibrio para tu máquina con `ollama run <nombre_modelo>:<tag>`.
Monitoriza el Uso de Recursos de Tu Sistema Durante la Ejecución:

Cuando un modelo está cargado y activo (ej: durante un `ollama run`), consumirá RAM y VRAM de GPU. Abre el Monitor de Actividad (macOS), Administrador de Tareas (Windows), o herramientas como `htop` / `nvidia-smi` (Linux) para ver cuánta memoria y uso de CPU/GPU está utilizando el proceso de Ollama. Esto te ayudará a entender por qué algunos modelos son más lentos o no caben en tu sistema.
Comprende el Concepto de la API Local (Servidor en Puerto 11434):

Ollama no es solo para la terminal. Cuando está instalado, inicia un servidor HTTP en tu máquina (por defecto en `http://localhost:11434`). Esta es la 'puerta' para que otras aplicaciones (escritas por ti o de terceros) interactúen con los modelos de Ollama programáticamente. El comando `ollama serve` lo inicia explícitamente si no se inicia automáticamente.
Aprende a Usar la API Local desde Código (Python, JavaScript, Curl):

La API es tu puerta para integrar Ollama en tus proyectos. Empieza con ejemplos sencillos. Puedes usar la herramienta de línea de comandos `curl` o librerías HTTP en tu lenguaje favorito (ej: `requests` en Python, `Workspace` en JavaScript) para enviar prompts a `http://localhost:11434/api/generate` o historiales de chat a `http://localhost:11434/api/chat`. Consulta la documentación de la API de Ollama.
Investiga la Creación de Modelos Personalizados con 'ModelFiles':

Si quieres un modelo que siempre use un prompt de sistema, tenga parámetros específicos por defecto o incluso incluya contexto adicional, explora el concepto de ModelFiles. Es un archivo de texto simple que defines y luego 'creas' un nuevo modelo local con `ollama create <nombre_nuevo_modelo> -f ./ruta/a/tu/Modelfile`.
Recuerda y Aprovecha la Ventaja de la Privacidad y el Uso Offline:

Este es el gran beneficio de Ollama. Tus datos de prompts se procesan localmente, no se envían a la nube. Una vez descargado el modelo, puedes usarlo sin internet. Ideal para datos sensibles, trabajo offline o simplemente para tener control total.
Lee la Documentación Oficial de Ollama:

El sitio web oficial (ollama.com) y, sobre todo, la sección de documentación (ollama.com/docs) son recursos esenciales. Allí encontrarás la referencia completa de la CLI, la API, ModelFiles, guías de integración con diferentes lenguajes y frameworks, y solución de problemas.

Herramientas relacionadas

Si te interesa Ollama, también podrías explorar estas herramientas:

Recursos útiles

Amplía tus conocimientos con estos enlaces y materiales: