Sync ollama docs from eab97e9f on 2026-10-12

docs/import.mdx

@@ -4,46 +4,10 @@ title: Importing a Model
 
 ## Table of Contents
 
-- [Importing a Safetensors adapter](#importing-a-fine-tuned-adapter-from-safetensors-weights)
 - [Importing a Safetensors model](#importing-a-model-from-safetensors-weights)
-- [Importing a GGUF file](#importing-a-gguf-based-model-or-adapter)
+- [Importing a GGUF model](#importing-a-gguf-model)
 - [Sharing models on ollama.com](#sharing-your-model-on-ollama-com)
 
-## Importing a fine tuned adapter from Safetensors weights
-
-First, create a `Modelfile` with a `FROM` command pointing at the base model you used for fine tuning, and an `ADAPTER` command which points to the directory with your Safetensors adapter:
-
-```dockerfile
-FROM <base model name>
-ADAPTER /path/to/safetensors/adapter/directory
-```
-
-Make sure that you use the same base model in the `FROM` command as you used to create the adapter otherwise you will get erratic results. Most frameworks use different quantization methods, so it's best to use non-quantized (i.e. non-QLoRA) adapters. If your adapter is in the same directory as your `Modelfile`, use `ADAPTER .` to specify the adapter path.
-
-Now run `ollama create` from the directory where the `Modelfile` was created:
-
-```shell
-ollama create my-model
-```
-
-Lastly, test the model:
-
-```shell
-ollama run my-model
-```
-
-Ollama supports importing adapters based on several different model architectures including:
-
-- Llama (including Llama 2, Llama 3, Llama 3.1, and Llama 3.2);
-- Mistral (including Mistral 1, Mistral 2, and Mixtral); and
-- Gemma (including Gemma 1 and Gemma 2)
-
-You can create the adapter using a fine tuning framework or tool which can output adapters in the Safetensors format, such as:
-
-- Hugging Face [fine tuning framework](https://huggingface.co/docs/transformers/en/training)
-- [Unsloth](https://github.com/unslothai/unsloth)
-- [MLX](https://github.com/ml-explore/mlx)
-
 ## Importing a model from Safetensors weights
 
 First, create a `Modelfile` with a `FROM` command which points to the directory containing your Safetensors weights:
@@ -66,81 +30,28 @@ Lastly, test the model:
 ollama run my-model
 ```
 
-Ollama supports importing models for several different architectures including:
+## Importing a GGUF model
 
-- Llama (including Llama 2, Llama 3, Llama 3.1, and Llama 3.2);
-- Mistral (including Mistral 1, Mistral 2, and Mixtral);
-- Gemma (including Gemma 1 and Gemma 2); and
-- Phi3
+Ollama does not quantize GGUF models during import. Prepare and quantize them first with a GGUF tool such as llama.cpp's [`llama-quantize`](https://github.com/ggml-org/llama.cpp/tree/master/tools/quantize).
 
-This includes importing foundation models as well as any fine tuned models which have been _fused_ with a foundation model.
-
-## Importing a GGUF based model or adapter
-
-If you have a GGUF based model or adapter it is possible to import it into Ollama. You can obtain a GGUF model or adapter by:
-
-- converting a Safetensors model with the `convert_hf_to_gguf.py` from Llama.cpp;
-- converting a Safetensors adapter with the `convert_lora_to_gguf.py` from Llama.cpp; or
-- downloading a model or adapter from a place such as HuggingFace
-
-To import a GGUF model, create a `Modelfile` containing:
+To import a single-file GGUF model, create a `Modelfile` containing:
 
 ```dockerfile
 FROM /path/to/file.gguf
 ```
 
-For a GGUF adapter, create the `Modelfile` with:
+For a split GGUF model, keep the original split filenames and use a wildcard that matches every shard.
 
 ```dockerfile
-FROM <model name>
-ADAPTER /path/to/file.gguf
+FROM /path/to/model-*.gguf
 ```
 
-When importing a GGUF adapter, it's important to use the same base model as the base model that the adapter was created with. You can use:
-
-- a model from Ollama
-- a GGUF file
-- a Safetensors based model
-
 Once you have created your `Modelfile`, use the `ollama create` command to build the model.
 
 ```shell
 ollama create my-model
 ```
 
-## Quantizing a Model
-
-Quantizing a model allows you to run models faster and with less memory consumption but at reduced accuracy. This allows you to run a model on more modest hardware.
-
-Ollama can quantize FP16 and FP32 based models into different quantization levels using the `-q/--quantize` flag with the `ollama create` command.
-
-First, create a Modelfile with the FP16 or FP32 based model you wish to quantize.
-
-```dockerfile
-FROM /path/to/my/gemma/f16/model
-```
-
-Use `ollama create` to then create the quantized model.
-
-```shell
-$ ollama create --quantize q4_K_M mymodel
-transferring model data
-quantizing F16 model to Q4_K_M
-creating new layer sha256:735e246cc1abfd06e9cdcf95504d6789a6cd1ad7577108a70d9902fef503c1bd
-creating new layer sha256:0853f0ad24e5865173bbf9ffcc7b0f5d56b66fd690ab1009867e45e7d2c4db0f
-writing manifest
-success
-```
-
-### Supported Quantizations
-
-- `q8_0`
-
-#### K-means Quantizations
-
-- `q4_K_S`
-- `q4_K_M`
-
 ## Sharing your model on ollama.com
 
 You can share any model you have created by pushing it to [ollama.com](https://ollama.com) so that other users can try it out.