Cómo configurar la conmutación multimodelo de Ollama: residente, memoria de video y tutoriales de Modelfile

Sat, 11 Jul 2026 09:32:06 +0800

Después de que Ollama haya instalado varios modelos, la primera pregunta que mucha gente tiene es: ¿Cómo cambiar rápidamente entre modelos de chat, código, traducción e incrustación? La segunda pregunta suele ser más práctica: ¿Por qué la anterior desaparece de la memoria de vídeo justo después de cambiar a otro modelo?

Permítanme comenzar con la conclusión: Ollama no necesita servir cada modelo por separado. Utilice ollama run <模型名> para el cambio diario; use ollama ps para ver qué modelos están actualmente en la memoria; utilice ollama stop <模型名> para liberar modelos innecesarios. La posibilidad de que varios modelos residan al mismo tiempo depende de si caben en la memoria o la memoria de video disponible, en lugar de cuántos modelos se descargan en el disco local.

Comandos de conmutación más utilizados

Primero enumere los modelos que ha descargado esta máquina:

`1`	`ollama ls`

Inicie un modelo de chat o código:

`1`	`ollama run qwen3:8b`

Cuando necesite cambiar a otro modelo, ejecute otro nombre directamente:

`1`	`ollama run qwen3:4b`

O cambie al modelo de incrustación para realizar pruebas:

`1`	`ollama run embeddinggemma "测试一段文本"`

Los archivos del modelo permanecen locales y no se volverán a descargar al cambiar. Los pesos deben colocarse en la memoria de video o en la memoria del sistema cuando se carga el modelo por primera vez. Si el modelo aún se conserva en la memoria, será más rápido volver a llamarlo.

`ollama ps`: Primero ver quién ocupa la memoria de video

Cuando el cambio no sea fluido, primero ejecute:

`1`	`ollama ps`

Enumera los modelos que se están ejecutando o que aún residen en la memoria. Lo más interesante a tener en cuenta aquí es el nombre del modelo, el tamaño, la ubicación del procesador y el tiempo de caducidad.

Si sólo tienes una tarjeta gráfica de tamaño medio y lanzas dos modelos grandes uno tras otro, Ollama podrá desinstalar el primer modelo para dejar espacio al segundo. Esta es una programación de recursos normal, no es que el modelo se pierda. El modelo todavía está en el disco y se recargará en la próxima llamada.

Si no desea esperar a que caduque naturalmente, puede detenerlo de forma proactiva:

`1`	`ollama stop qwen3:8b`

Luego use ollama ps para confirmar que se ha liberado la memoria de video.

Tiempo de permanencia predeterminado: 5 minutos

Por defecto, Ollama conserva un modelo durante aproximadamente 5 minutos después de su último uso. Este diseño es adecuado para preguntas continuas: la primera carga es un poco más lenta y las solicitudes posteriores no necesitan mover repetidamente el mismo modelo a la memoria de video.

Si utiliza varios modelos a la vez en una máquina con poca memoria de video, 5 minutos pueden causar la sensación de “acabo de terminar de ejecutar uno y la memoria de video aún no ha sido devuelta”. Existen tres métodos de control en este momento.

Método 1: desinstalar inmediatamente después de una llamada

Establezca keep_alive en 0 a través de API:

curl http://localhost:11434/api/generate -d '{
  "model": "qwen3:8b",
  "prompt": "用一句话解释 KV cache",
  "keep_alive": 0
}'

Esto es adecuado para situaciones en las que el modelo es grande, la memoria de vídeo es escasa y cada tarea es independiente.

Método 2: mantener el modelo residente durante mucho tiempo

Si utiliza el mismo modelo de código todo el día, puede establecer keep_alive en un número negativo:

curl http://localhost:11434/api/generate -d '{
  "model": "qwen3:8b",
  "keep_alive": -1
}'

De esta manera el modelo permanecerá en la memoria hasta que manualmente ollama stop o se reinicie el servicio. No configure esto para varios modelos grandes cuando no tenga suficiente memoria de video.

Método 3: modificar globalmente la hora residente predeterminada

OLLAMA_KEEP_ALIVE se puede configurar para los servicios de Ollama. Por ejemplo, si desea que todos los modelos se conserven durante 30 segundos de forma predeterminada:

`1`	`OLLAMA_KEEP_ALIVE=30s`

En Windows, Ollama hereda las variables de entorno del sistema o del usuario. Una vez que se completa la configuración, debe salir de Ollama desde la bandeja y reiniciar desde el menú Inicio. Si Ollama es administrado por systemd en Linux, configure la variable de entorno del servicio y reinicie el servicio.

keep_alive en la solicitud API anulará el OLLAMA_KEEP_ALIVE global, por lo que es más adecuado establecer diferentes políticas para diferentes tareas.

La clave para la persistencia multimodelo: `OLLAMA_MAX_LOADED_MODELS`

OLLAMA_MAX_LOADED_MODELS se utiliza para limitar la cantidad de modelos que se pueden cargar simultáneamente. Por ejemplo, solo desea que el servicio conserve como máximo un modelo:

`1`	`OLLAMA_MAX_LOADED_MODELS=1`

El propósito de esta configuración es evitar llenar la memoria de video durante mucho tiempo cuando se gira el modelo, pero no es un método para “forzar un modelo grande a caber en la tarjeta gráfica”. Durante la inferencia de GPU, un nuevo modelo puede residir simultáneamente con otros modelos solo si puede caber completamente en la memoria de video disponible. De lo contrario, Ollama descargará el modelo antiguo o colocará el modelo en una ruta de memoria más lenta.

Para una única tarjeta gráfica de 8GB, 12GB o 16GB, la estrategia más estable suele ser:

escena	sugerencia
Utilice solo un modelo de chat cada día	`OLLAMA_MAX_LOADED_MODELS=1`, mantener durante 5 minutos o menos
Chat de modelo pequeño + Incrustación	Primero verifique la ocupación real de ambos. Si puedes dejarlos al mismo tiempo, aumenta la cantidad.
El modelo de código y el modelo general se utilizan alternativamente.	No insistas en la doble residencia, cambia según las tareas y toma la iniciativa `ollama stop`
Llamada multiusuario del servidor	Combine el tamaño del modelo, la memoria de video y el volumen de solicitudes, y luego configure la simultaneidad y la cola

No ignore la concurrencia: los contextos también consumen memoria

Los problemas multimodelo no se refieren sólo a los pesos de los modelos. Cada solicitud paralela aumenta el consumo de recursos del contexto y la caché KV.

Ollama también proporciona dos variables de entorno relacionadas:

1
2

OLLAMA_NUM_PARALLEL=1
OLLAMA_MAX_QUEUE=512

OLLAMA_NUM_PARALLEL controla la cantidad de solicitudes que el mismo modelo puede procesar en paralelo. Cuando aumenta el número de concurrencia, los recursos necesarios aumentarán con la longitud del contexto. Cuando se utiliza una sola tarjeta localmente, suele ser más fácil solucionar el problema dejando el valor predeterminado o configurándolo explícitamente en 1; no cargue varios modelos mientras aumenta la simultaneidad.

OLLAMA_MAX_QUEUE es la cantidad de solicitudes que se pueden poner en cola cuando está ocupada. Solo resuelve las colas y no aumenta la memoria de video.

Utilice Modelfile para crear alias fijos para diferentes propósitos

Si siempre configura repetidamente palabras de aviso del sistema, temperatura o políticas de contexto para el mismo modelo base, puede usar Modelfile para crear múltiples alias locales. En lugar de duplicar un conjunto completo de pesos, definen diferentes configuraciones basadas en un modelo.

Por ejemplo, cree un archivo de configuración basado en código Modelfile.code:

1
2
3

FROM qwen3:8b
SYSTEM 你是一个中文编程助手。先说明修改思路，再给出可运行的最小代码。
PARAMETER temperature 0.2

Crea un alias de modelo:

`1`	`ollama create qwen3-code -f Modelfile.code`

Luego ejecuta directamente:

`1`	`ollama run qwen3-code`

También puedes hacer una versión orientada a la escritura:

1
2
3

FROM qwen3:8b
SYSTEM 你是中文写作助手，回答前先给结论，再给必要的结构化说明。
PARAMETER temperature 0.7

1
2

ollama create qwen3-write -f Modelfile.write
ollama run qwen3-write

Nota: qwen3-code y qwen3-write, aunque comparten la misma orientación base, siguen siendo configuraciones de modelo diferentes en tiempo de ejecución. Cuando la memoria de vídeo es escasa, no asuma que pueden residir indefinidamente al mismo tiempo.

Proporcione scripts o API para cambiar modelos por tarea

En la API, el nombre del modelo en sí es el campo de enrutamiento. No es necesario que el script reinicie el servicio, simplemente pase un model diferente según la tarea:

curl http://localhost:11434/api/chat -d '{
  "model": "qwen3-code",
  "messages": [
    {"role": "user", "content": "解释这段 Python 的异常处理逻辑"}
  ],
  "stream": false,
  "keep_alive": "10m"
}'

Una división común del trabajo es:

Modelo pequeño: clasificación, reescritura, resumen, preguntas y respuestas simples;
Modelo de código: interpreta el almacén, genera scripts y corrige errores;
Modelo de incrustación: recuperación de vectores, no responsable del chat;
Modelos más grandes: problemas complejos, cargados bajo demanda, liberados después de su uso.

Escribir “qué modelo elegir” en el enrutamiento de tareas del código hace que sea más fácil controlar la velocidad y la memoria que concentrar todo el trabajo en un modelo grande.

Errores comunes en Windows

La variable de entorno se cambió pero no tuvo efecto.

Después de modificar OLLAMA_KEEP_ALIVE, OLLAMA_MAX_LOADED_MODELS o OLLAMA_MODELS en Windows, debe salir del programa de bandeja Ollama en ejecución y reiniciar. Por lo general, simplemente reabrir PowerShell no es suficiente.

Los archivos de modelo llenan el disco del sistema.

Puede configurar OLLAMA_MODELS para mover el directorio del modelo a otro disco, por ejemplo:

`1`	`OLLAMA_MODELS=D:\OllamaModels`

Guarde y reinicie Ollama. Antes de migrar modelos existentes, confirme el espacio en disco y los permisos del directorio. No elimine el directorio anterior solo para cambiar el volumen.

Pensé que el modelo había sido eliminado.

Después de cambiar, no puede ver el modelo anterior con ollama ps, lo que simplemente significa que se ha descargado de la memoria; aún puedes ver el modelo descargado con ollama ls. Los archivos del modelo local se eliminarán únicamente ejecutando el siguiente comando:

`1`	`ollama rm qwen3:8b`

Un conjunto de estrategias predeterminadas adecuadas para una sola tarjeta.

Si solo tiene una tarjeta gráfica de consumo y cambia con frecuencia entre varios modelos, puede comenzar con esta estrategia:

1
2
3

OLLAMA_MAX_LOADED_MODELS=1
OLLAMA_KEEP_ALIVE=2m
OLLAMA_NUM_PARALLEL=1

Luego llame al modelo qwen3-code, qwen3-write o Incrustación por tarea. Cuando necesite ejecutar un modelo grande, ejecute ollama stop primero para detener modelos innecesarios; cuando encuentre contextos largos o archivos grandes, reduzca la cantidad de simultaneidad y números residentes.

El objetivo de esta configuración no es permitir que la tarjeta gráfica cargue tantos modelos como sea posible al mismo tiempo, sino permitir que cada cambio sea predecible y la memoria gráfica no se llene con modelos que se olvidarán durante mucho tiempo.

Resumir

Solo hay cuatro comandos principales para la conmutación multimodelo de Ollama:

ollama ls
ollama run <模型名>
ollama ps
ollama stop <模型名>

Si desea administrar mejor los modelos para diferentes propósitos, use Modelfile para crear alias; si desea controlar la carga y liberación, use keep_alive, OLLAMA_KEEP_ALIVE y OLLAMA_MAX_LOADED_MODELS. Primero determine la cantidad de residentes simultáneos de acuerdo con la memoria de video y luego considere el enrutamiento y la concurrencia multimodelo. La configuración será mucho más estable.

referirse a:

Model Management on KnightLi Blog