Entradas Mensuales

Síguenos en:

Canal Oficial Telegram de elhacker.NET Grupo Facebook elhacker.NET Twitter elhacker.NET Canal Youtube elhacker.NET Comunidad Steam: Grupo elhacker.NET Mastodon

Entradas populares

PostHeaderIcon Instalar y configurar Ollama (servidor Local para servir modelos LLM de IA)

jueves, 20 de noviembre de 2025 | Publicado por el-brujo | Editar entrada

 Ollama es una aplicación que sirve como cliente y centro neurálgico para el uso de modelos LLM de inteligencia artificial. Lo que hace es centralizarlo todo, y permitir la carga de modelos, así como interactuar con ellos.



Hoy en día, todos conocemos ChatGPT. Sin embargo, debemos ser conscientes que tanto ChatGPT como otros productos como Gemini, Claude o Grok, por citar algunos, son modelos de IA (LLM) basados en Cloud.

¿Qué quiere decir que están basados en Cloud? Pues que realmente estamos usando un servicio de una empresa, y por lo tanto, estamos enviando nuestra información a dicha empresa. En muchas empresas esto es un tema bastante delicado, ya que trabajan con datos sensibles, o incluso es ilegal enviar esos datos a estas compañías.





Ollama vs. Llama.cpp: ¿Cuáles son las diferencias?


Es conveniente aclarar la relación entre Ollama y llama.cpp, ya que están estrechamente relacionados, pero tienen fines diferentes.

llama.cpp: Es la biblioteca C/C++ fundamental y de alto rendimiento responsable de la tarea principal de la inferencia LLM. Se encarga de cargar los pesos del modelo, procesar los tokens de entrada y generar tokens de salida de manera eficiente, 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 las tareas computacionales más pesadas.


Ollama: Es una aplicación completa construida en torno a llama.cpp (y potencialmente otros backends futuros). Ollama proporciona una capa fácil de usar en la parte superior, que ofrece:


  • Una sencilla interfaz de línea de comandos (CLI) para facilitar la interacción (ollama run, ollama pull, etc.).
  • Un servidor API REST integrado para la integración programática.
  • Gestión optimizada de modelos (descarga desde una biblioteca, almacenamiento local, actualizaciones).
  • El sistema Modelfile para la personalización y la 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 se podría utilizar llama.cpp directamente compilándolo y ejecutando sus herramientas de línea de comandos, esto requiere un esfuerzo técnico considerablemente mayor en cuanto a la configuración, la conversión de modelos y la gestión de parámetros. Ollama integra toda esta potencia en una aplicación accesible y fácil de usar, lo que hace que los LLM locales sean prácticos para un público mucho más amplio, especialmente para los principiantes. Piense en llama.cpp como los componentes del motor de alto rendimiento y en Ollama como el vehículo completamente montado, fácil de usar y listo para conducir.

¿Qué es Ollama?

  • Ollama (Open-source Library for AI Models and Applications)

Ollama es una herramienta de inteligencia artificial (IA) generativa diseñada para permitir a los usuarios generar contenido nuevo y realizar análisis avanzados de datos mediante modelos de lenguaje.

Ollama nos permitirá usar LLM (Large language model), esto es, modelos de lenguage entrenados para la IA, podrán ser de código abierto o de pago, podrán ser 100% offline o no, al gusto. Obviamente y dependiendo el LLM que usemos necesitaremos más o menos potencia, esto es, tener una GPU para que las respuestas sean inmediatas. Podremos usar la API de Ollama para hacerle preguntas de manera remota con otros sistemas, muy muy potente. Y os recomiendo Open WebUI como interfaz GUI para Ollama, así con nuestro navegador tendremos la interfaz que esperas para poder trabajar con tu IA cómodamente.

Razones para recomendarlo:

  • Ofrece un buen soporte para modelos locales;
  • Admite la calificación de mensajes a través de anotaciones RLHF para ajustar los modelos locales;
  • Admite la marcación de conversaciones para clasificar y ubicar fácilmente chats específicos;
  • Permite la descarga o eliminación de modelos directamente desde la interfaz;
  • Permite especificar diferentes modelos para la conversación utilizando @;

 

Lo dicho, necesitaremos una GPU para tener el mejor rendimiento posible, dependerá del LLM que usemos y los GB que requiera cada modelo, de esta manera las respuestas serán inmediatas. En cuanto al hardware compatible es bastante extenso (NVIDIA, AMD, Apple M1…), os dejo aquí su listado.

Es parte de la creciente categoría de herramientas de IA que utilizan redes neuronales profundas para entender y producir lenguaje natural, lo que la hace útil en una variedad de aplicaciones, desde la generación automática de textos hasta la creación de scripts personalizados.

Características principales de Ollama:

  1. Generación de contenido: Ollama puede generar texto coherente y relevante a partir de prompts o instrucciones dadas por el usuario, lo que la convierte en una herramienta valiosa para la automatización de tareas como la redacción de informes, la creación de documentación, y la elaboración de respuestas a incidentes de ciberseguridad.

  2. Análisis de datos: Utilizando modelos avanzados de procesamiento de lenguaje natural (NLP), Ollama puede analizar grandes volúmenes de datos para extraer información útil, identificar patrones de comportamiento, y ofrecer insights que facilitan la toma de decisiones.

  3. Personalización y ddaptabilidad: Ollama se puede adaptar a diferentes contextos y necesidades, permitiendo a los usuarios ajustar sus salidas según las especificaciones del proyecto o las demandas del entorno de trabajo.

  4. Interfaz de usuario amigable: A pesar de su sofisticación técnica, Ollama está diseñada para ser accesible tanto para expertos en inteligencia artificial como para profesionales en campos no técnicos, facilitando su adopción en diferentes sectores.

Opciones de la línea de comandos y de la GUI

Ollama funciona principalmente a través de una interfaz de línea de comandos (CLI), que te proporciona un control preciso sobre los modelos. La CLI permite comandos rápidos para extraer, ejecutar y gestionar modelos, lo que es ideal si te sientes cómodo trabajando en una ventana de terminal.

Ollama también admite herramientas de interfaz gráfica de usuario (GUI) de terceros, como Open WebUI, para quienes prefieran un enfoque más visual.


Lo primero que tienes que hacer es entrar en la web de Ollana, que es un programa que sirve para instalar y hacer funcionar de forma local varios modelos de inteligencia artificial. Para esto, entra en ollama.com, y pulsa en el botón Download que te aparecerá.
 
curl -fsSL https://ollama.com/install.sh | sh

Ahora, irás a la página donde tienes que elegir el sistema operativo para el que quieres bajarte el programa. Una vez lo hayas elegido, pulsa en el botón Download. Por defecto la web mostrará el sistema que estás usando, pero podrás descargar el ejecutable de cualquier otro.

Cuando lo descargues, lanza el programa de instalación. Instalar Ollama es muy sencillo, solo tienes que pulsar en el botón de siguiente en la pantalla de presentación, y luego pulsar en el botón Install en la pantalla de instalación.



Ahora viene la única parte un poco compleja. Una vez instalado, tienes que lanzar la aplicación de Ollama. Aparentemente no pasará nada, no se abrirá nada. En este punto, con Ollama funcionando tienes que abrir la terminal de tu sistema operativo, el símbolo de sistema en Windows. Allí, tienes que escribir el código para instalar o ejecutar DeepSeek. Es el siguiente:

 

ollama run <modelo>:<etiqueta>


  • ollama pull deepseek-r1:8b: Esto solo descarga DeepSeek R1 en su versión 8B. Esta versión es algo más grande que las inferiores, pero es bastante más efectiva.
  • ollama run deepseek-r1:8b: Esto instala y lanza DeepSeek R1 en la versión 8b o en la que elijas

Para utilizar Ollama:

  • descargar modelos: ollama pull llama2. Existen muchos modelos en https://ollama.com/library
  • ejecutar modelos: ollama run lava y tendrás el modelo listo en una terminal
  • ver los modelos descargados: ollama list
  • eliminar un modelo descargado: ollama rm llama2
  • también puedes arrancar Ollama desde la terminal sin necesidad de la aplicación de escritorio con ollama serve
  • ejecutar una consulta desde el prompt ollama run llama2 "why is ths sky blue?"
  • ejecutar una consulta desde el prompt pasándole un archivo como argumento para el contexto ollama run llama2 "haz un resumen del siguiente archivo: $(cat README.md)"
  • ejecutar una consulta multimodal sobre una imagen en tu disco local ollama run llava "what is in this image? /users/me/images/myimage.jpg"
  • saber más: ollama --help
 
Ejemplo comando:

ollama ps

Resultado: 

NAME                  ID              SIZE     PROCESSOR    CONTEXT    UNTIL

gemma3:27b-it-fp16    b7d58e2e179e    65 GB    100% GPU     8192       Forever

Asegúrate  que el modelo está cargado siempre 100% en la GPU, si combinas CPU con GPU irá muy lento


ComandoDescripción
ollama serve
Starts Ollama on your local system.
ollama create <new_model>
Creates a new model from an existing one for customization or training.
ollama show <model>
Displays details about a specific model, such as its configuration and release date.
ollama run <model>
Runs the specified model, making it ready for interaction
ollama pull <model>
Downloads the specified model to your system.
ollama list
Lists all the downloaded models.
ollama ps
Shows the currently running models.
ollama stop <model>
Stops the specified running model.
ollama rm <model>
Removes the specified model from your system.

Modelos LLM locales



Existen muchísimos modelos LLM locales. Ollama dispone de una web donde puedes buscar los últimos modelos publicados. Puedes organizarlos por popularidad, recientes o filtrar por tipos de modelos, donde actualmente se encuentran:

  • Embedding: Convierte texto en vectores. Útil para recomendaciones, clasificaciones, búsquedas...
  • Tools: Permiten interactuar con funciones externas (API, BDD, etc...)
  • Thinking: Permiten procesos de razonamiento, explicando paso a paso.
  • Vision: Permiten leer y describir imágenes.

Existen muchos modelos, subidos por diferentes empresas, donde cada uno de esos modelos tiene diferentes tamaños indicados por un número 1B, 2B, 4B... Ese número es la cantidad de parámetros del modelo (1B = mil millones de parámetros). Cuantos más parámetros, más complejo es el modelo, más calculos puede hacer y más recursos necesita.

Requisitos para usar modelos LLM

Para utilizar modelos LLM locales, generalmente necesitamos un buen hardware en nuestra máquina, ya que deben cargarse en memoria y son bastante exigentes respecto a recursos, especialmente respecto a GPU (procesamiento de tarjeta gráfica).

En la siguiente tabla se puede observar un resumen aproximado, para saber de forma orientativa, la máquina que necesitaríamos para utilizar un modelo LLM de dicha categoría y que funcione relativamente rápido.

Observa que hay 4 categorías principales:

  • 🟩 Modelos mini: De 270M a 4B. Ideales para móviles o sistemas pequeños.
  • 🟨 Modelos pequeños: De 4B a 14B. Modelos domésticos, opción equilibrada actual.
  • 🟧 Modelos medianos: De 14B a 70B. Modelos que requieren muy buen hardware para poder usarlos.
  • 🟥 Modelos grandes: Mayores a 70B. Modelos muy potentes con requisitos gigantescos de hardware.

Aproximadamente, un modelo de 1.5B ocupará alrededor de 1GB de tamaño.

API de Ollama

Además de esto, Ollama dispone de una API mediante la cuál podemos enviar prompts y obtener el resultado que nos devuelve el modelo, permitiendo configurar todos sus parámetros.



En una próxima entrada en el blog hablaremos única y exclusivamente de la API de Ollama y cómo utilizarla con diferentes lenguajes Python, JavaScript, PHP, con ejemplos.

Longitud del contexto de Ollama


  • Longitud del contexto de Ollama: el parámetro num_ctx 

La longitud del contexto, a menudo denominada 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.

Qué representa: num_ctx define el número máximo de tokens que el modelo puede «ver» o procesar simultáneamente. Esto incluye todo: la solicitud inicial del sistema, todos los mensajes anteriores del usuario y las respuestas del asistente en el historial de chat actual, y la última solicitud 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, lo que evita que pierda el hilo o se repita.

Análisis de documentos: al procesar documentos grandes (por ejemplo, para resumirlos o responder preguntas), la ventana de contexto determina la cantidad de documento que el modelo puede considerar a la vez.

Instrucciones complejas: las instrucciones que se basan en detalles proporcionados mucho antes en la solicitud requieren una ventana de contexto suficiente para ser comprendidas correctamente.

 Límites inherentes al modelo: todos los LLM están preentrenados con una longitud máxima de contexto específica (por ejemplo, 2048, 4096, 8192, 32k, 128k o incluso millones en el caso de los modelos de investigación más avanzados). Aunque se puede configurar num_ctx en Ollama, establecerlo por encima del límite de entrenamiento original del modelo puede provocar un comportamiento impredecible, un rendimiento degradado (el modelo podría «olvidar» cosas fuera de su ventana de entrenamiento) o errores. Establecerlo por debajo siempre es seguro, pero limita la capacidad del modelo.

Consumo de recursos: procesar una ventana de contexto más grande requiere mucha más RAM y VRAM (memoria GPU) y lleva más tiempo de cálculo. Debe equilibrar la capacidad de contexto deseada con las limitaciones de su hardware.

Encontrar el num_ctx predeterminado para un modelo Ollama: utilice el comando

 ollama show <nombre_del_modelo:etiqueta> 

y busque la línea PARAMETER num_ctx en la sección Modelfile que se muestra. Los modelos Ollama suelen venir con un valor predeterminado razonable (por ejemplo, 4096 u 8192).

Cambiar el num_ctx para Ollama:


Temporal (durante la ejecución de Ollama): utilice el comando de barra: 

/set parameter num_ctx 8192

Por solicitud de API: inclúyalo en el objeto JSON de opciones:

 curl ... -d '{ «model»: «...», “prompt”: «...», «options»: { «num_ctx»: 8192 } }'
    
Persistente (modelo Ollama personalizado): cree o modifique un archivo Modelfile y añada o cambie la línea PARAMETER num_ctx <valor>, luego compile el modelo utilizando ollama create. Esto establece el tamaño de contexto predeterminado para ese modelo personalizado.

Elija un valor num_ctx que se adapte a sus tareas habituales. Para preguntas y respuestas sencillas, puede bastar con una ventana más pequeña (por ejemplo, 4096). Para chats largos o resúmenes de documentos extensos, le conviene utilizar la ventana de contexto más grande que su hardware y el modelo puedan soportar razonablemente (por ejemplo, 8192, 16384 o más, si está disponible).

Explicación de los parámetros del modelo Ollama


Los LLM tienen ajustes internos, o parámetros, que se pueden modificar para influir en la forma en que generan el texto. Ollama permite controlar muchos de ellos:

  • Temperatura: (por defecto: ~0,7-0,8) Controla la aleatoriedad o «creatividad» del resultado.
  • Valores más bajos (por ejemplo, 0,2): hacen que el resultado sea más determinista, centrado y predecible. Son adecuados para respuestas basadas en hechos o para la generación de código.
  • Valores más altos (por ejemplo, 1,0, 1,2): aumentan la aleatoriedad, lo que hace que el resultado sea más diverso y creativo, pero potencialmente menos coherente. Son adecuados para la lluvia de ideas o la escritura de historias.
  • top_p (muestreo del núcleo): (predeterminado: ~0,9) Establece un umbral de probabilidad. El modelo solo tiene en cuenta los siguientes tokens más probables cuya masa de probabilidad acumulada supere top_p. Al reducir top_p (por ejemplo, 0,5), se restringen las opciones a las palabras más probables, lo que aumenta la coherencia, pero puede reducir la novedad. Los 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 (por ejemplo, 10) hace que la salida sea más específica; un top_k más alto permite una mayor variedad. A menudo se considera que top_p es más eficaz que top_k. Por lo general, se establece uno u otro, pero 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. Establezca en -1 para una generación ilimitada hasta que se cumpla una condición de detención.
  • stop: Una lista de secuencias de texto específicas. Si el modelo genera una de estas secuencias, dejará de producir resultados inmediatamente. Útil para evitar frases demasiado largas o garantizar que el modelo se detenga después de responder. Ejemplo: [«\n», «Usuario:», «<|eot_id|>»].
  • num_ctx: Define el tamaño de la ventana de contexto del modelo. Véase la explicación detallada más arriba
    Otros parámetros: Ollama expone muchos otros parámetros heredados de llama.cpp (como repeat_penalty, seed, mirostat, GPU layers num_gpu, etc.) para un control más preciso. Consulte la documentación de Ollama y llama.cpp para obtener más detalles.

Puede configurarlos temporalmente utilizando el parámetro /set en ollama run, de forma persistente en un Modelfile utilizando la instrucción PARAMETER, o por solicitud a través del objeto de opciones en la API de Ollama.

Formatos de ficheros: Safetensors y GGUF

Partiendo de la base de que un tensor es un objeto matemático (básicamente un array que puede tener múltiples dimensiones) para la representación de datos, Safetensor es un formato de fichero desarrollado por Hugging Face que almacena dichos tensors de forma segura. A diferencia de otros formatos, Safetensor está habilitado en un formato de solo lectura (evitando la ejecución de código no deseado) y diseñado para la eficiencia y portabilidad de datos.



Un ejemplo de lo que es un tensor si lo trasladamos al mundo real, podría ser:

  • Scalar (tensor de dimensión 0): el valor de la intensidad de un pixel en una imagen en escala de grises.
  • Vector (tensor de dimensión 1): para una imagen en escala de grises, una línea de pixels puede ser representada como un vector.
  • Matriz (tensor de dimensión 2): una imagen en escala de grises entera se puede representar como una matriz.
  • Tensor de 3 dimensiones: una imagen a color. En una imagen a color, cada pixel no solo tiene un valor para la intensidad, tiene tres (RGB). En este caso, se puede pensar la imagen a color como tres matrices apiladas juntas, una para cada color.


Entre otros formatos de ficheros, también se puede encontrar GGUF (GPT-Generated Unified Format), que posibilita la gestión de LLMs de forma optimizada. Este formato permite, además de codificar los tensors, incluir un conjunto de metadatos y dar soporte a diversos tipos de cuantización y fine-tuning.

GGUF está pensado para la extensibilidad y versatilidad, pudiendo incorporar nueva información sin romper la compatibilidad con los modelos antiguos además de los que puedan venir en el futuro.

Cómo importar modelos externos a Ollama (GGUF, Safetensors)

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

Importación de modelos GGUF a Ollama: GGUF es un formato popular diseñado específicamente para llama.cpp y motores de inferencia similares. Empaqueta los pesos del modelo (a menudo precuantizados), la información del tokenizador y los metadatos en un único archivo. Suele ser el formato más fácil de importar.

  • Descargue el archivo .gguf (por ejemplo, zephyr-7b-beta.Q5_K_M.gguf).
  • Cree un archivo Modelfile mínimo (por ejemplo, ZephyrImport.modelfile):
# ZephyrImport.modelfile
FROM ./zephyr-7b-beta.Q5_K_M.gguf

# Crucial: Add the correct prompt template for this model!
# (Look up the model's required template format)
TEMPLATE """<|system|>
{{ .System }}</s>
<|user|>
{{ .Prompt }}</s>
<|assistant|>
{{ .Response }}</s>
"""
PARAMETER num_ctx 4096 # Set a reasonable default context
SYSTEM "You are a friendly chatbot." # Optional default system prompt

  • Crea el modelo Ollama: 

ollama create my-zephyr-gguf -f ZephyrImport.modelfile.

Importación de modelos Safetensors (pesos completos) a Ollama: Safetensors es un formato seguro y rápido para almacenar tensores de modelos. Si dispone del conjunto completo de pesos y archivos de configuración para un modelo en este formato:


    Asegúrese de que todos los archivos necesarios (archivos de pesos *.safetensors, config.json, tokenizer.json, special_tokens_map.json, tokenizer_config.json, etc.) se encuentran en un único directorio (por ejemplo, /data/models/Mistral-7B-v0.1-full/).

    Cree un archivo Modelfile que haga referencia a este directorio: 

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

# Add required TEMPLATE, PARAMETER, SYSTEM instructions
TEMPLATE """[INST] {{ if .System }}{{ .System }} \n{{ end }}{{ .Prompt }} [/INST]
{{ .Response }}"""
PARAMETER num_ctx 4096
PARAMETER temperature 0.7

Cree el modelo: ollama create my-mistral-safetensors -f MistralImport.modelfile. Ollama intentará cargar arquitecturas compatibles. Si el modelo no está cuantificado (por ejemplo, FP16), puede cuantificarlo opcionalmente durante la creación (véase más abajo).


 

Variables de entorno de Ollama

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

Variables clave del entorno Ollama para la 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 (solo escucha en la interfaz de bucle invertido, accesible solo desde la misma máquina).
    Ejemplo: 0.0.0.0:11434 (escucha en todas las interfaces de red disponibles, lo que hace que Ollama sea accesible desde otros dispositivos de su red local. Advertencia: asegúrese de que existen las reglas de firewall adecuadas si expone Ollama externamente).
Ejemplo: 192.168.1.100:11500 (escucha solo en una dirección IP local específica y un puerto personalizado)
.
  • OLLAMA_MODELS: Es fundamental que esta variable le permita especificar una ruta de directorio personalizada donde Ollama debe almacenar y buscar los modelos descargados. Esto es extremadamente útil si su unidad predeterminada (donde reside ~/.ollama o C:\Users\<User>\.ollama) tiene poco espacio o si prefiere organizar los modelos en un SSD dedicado o en una unidad más grande.
    Ejemplo (Linux/macOS): export OLLAMA_MODELS=/mnt/large_drive/my_ollama_models
    Ejemplo (Windows): Establezca OLLAMA_MODELS en D:\ollama_data a través de las Propiedades del sistema.

Importante: Asegúrese de que el directorio existe y de que la cuenta de usuario que ejecuta el proceso del servidor Ollama tiene permisos completos de lectura y escritura para esta ruta personalizada.

  • OLLAMA_ORIGINS: Gestiona el intercambio de recursos entre orígenes (CORS) para la API de Ollama. Por defecto, los navegadores web restringen las páginas web para que no realicen solicitudes de API a dominios (orígenes) diferentes al que sirve la página. Si está ejecutando una interfaz de usuario web independiente (como Open WebUI o Lobe Chat) servida desde un origen diferente (por ejemplo, http://localhost:3000) que necesita llamar a su API de Ollama (en http://localhost:11434), debe añadir el origen de la interfaz de usuario 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. Úselo con precaución, especialmente si OLLAMA_HOST no es 127.0.0.1, ya que esto podría exponer ampliamente su API). Puede incluir protocolos como chrome-extension://*.

  • OLLAMA_DEBUG: Establezca en 1 para habilitar el registro detallado de depuración. Esto proporciona información mucho más detallada sobre las operaciones internas de Ollama, incluidos los pasos de detección de la GPU, los detalles de carga del modelo y los posibles errores, lo cual es muy valioso para la resolución de problemas.
Ejemplo: export OLLAMA_DEBUG=1


  • OLLAMA_DEBUG= o OLLAMA_DEBUG=0 o OLLAMA_DEBUG=false: los valores no establecidos, vacíos o falsos establecen el nivel INFO predeterminado.
  • OLLAMA_DEBUG=1 o OLLAMA_DEBUG=true: establece el nivel DEBUG.
  • OLLAMA_DEBUG=2: establece el nivel TRACE.

  • OLLAMA_KEEP_ALIVE: Controla cuánto tiempo Ollama mantiene un modelo cargado en la memoria después de su última solicitud. Por defecto, puede ser alrededor de 5 minutos (5 m). Si se establece en 0, el modelo se descarga inmediatamente después de su uso (ahorra RAM/VRAM, pero aumenta el tiempo de carga para la siguiente solicitud). Establecerlo en una duración mayor (por ejemplo, 30 m) o -1 (mantiene la carga indefinidamente hasta que el servidor se detiene) 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 que se utilizan si Ollama necesita enrutar sus solicitudes de Internet salientes (por ejemplo, al ejecutar ollama pull para descargar modelos de ollama.com) a través de un servidor proxy, algo habitual 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:

  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.



Etiquetas: , , , , ,

0 comentarios :

Publicar un comentario

Los comentarios pueden ser revisados en cualquier momento por los moderadores.

Serán publicados aquellos que cumplan las siguientes condiciones:
- Comentario acorde al contenido del post.
- Prohibido mensajes de tipo SPAM.
- Evite incluir links innecesarios en su comentario.
- Contenidos ofensivos, amenazas e insultos no serán permitidos.

Debe saber que los comentarios de los lectores no reflejan necesariamente la opinión del STAFF.