# LocalAI relative to Ollama > Everything the scanned sources say about LocalAI relative to Ollama: 102 source-anchored units across 5 sources, grouped by facet. Parent: [Ollama alternatives and model sourcing](https://llms-explorer.com/tree/ollama-alternatives-and-model-sourcing/) · 10 facets · 102 facts · page: https://llms-explorer.com/tree/localai/ ## Definitions - LocalAI is MIT-licensed and was created by Ettore Di Giacinto (mudler), maintained by the LocalAI team. — [source](https://github.com/mudler/LocalAI) - The macOS DMG is not signed by Apple, so after install the user must run `sudo xattr -d com.apple.quarantine /Applications/LocalAI.app`. — [source](https://github.com/mudler/LocalAI) - **LocalAI** is the open-source AI engine. Run any model - LLMs, vision, voice, image, video - on any hardware. No GPU required. — [source](https://github.com/mudler/LocalAI) - > **Note:** The DMG is not signed by Apple. After installing, run: `sudo xattr -d com.apple.quarantine /Applications/LocalAI.app`. See [#6268](https://github.com/mudler/LocalAI/issues/6268) for details. — [source](https://github.com/mudler/LocalAI#macos) - LocalAI is a community-driven project created by [Ettore Di Giacinto](https://github.com/mudler/) and maintained by the [LocalAI team](#team). — [source](https://github.com/mudler/LocalAI#license) - The Model Gallery is the simplest way to install models. It provides pre-configured models ready to use. — [source](https://localai.io/docs/getting-started/models/) ## Structure and components - - **June 2026**: New native biometric backends from the LocalAI team: [voice-detect.cpp](https://github.com/localai-org/voice-detect.cpp) for speaker recognition and voice analysis (ECAPA-TDNN, WeSpeaker, ERes2Net, CAM++, wav2vec2 age/gender/emotion) and [face-detect.cpp](https://github.com/mudler/face-detect.cpp) for face detection, recognition, demographics and anti-spoofing (SCRFD/ArcFace, YuNet/SFace). Both are from-scratch C++/ggml engines with no Python or onnxruntime at inference, self-contained GGUF weights, bit-exact parity with the reference, and GPU cuDNN parity, replacing the heavi — [source](https://github.com/mudler/LocalAI#latest-news) - The `` component can be used in your model card to showcase your generated images and videos. — [source](https://huggingface.co/docs/hub/model-cards-components.md#the-gallery-component) ## How it works - LocalAI uses a small core plus separate backend images (llama.cpp, vLLM, SGLang, MLX, whisper.cpp, diffusers, and others), each pulled on demand only when a model needs it. — [source](https://github.com/mudler/LocalAI) - Ollama clients can list configured models with GET /api/tags and loaded models with GET /api/ps. Each entry includes size in bytes when LocalAI can resolve a non-empty primary weights file on disk. This is the size of that file, not the total size of a multi-file model or its memory use. Unknown sizes are omitted; /api/ps also omits size_vram because per-model VRAM use is not available. — [source](https://localai.io/docs/getting-started/models/) - When to Choose: Best for users needing multimodal AI capabilities beyond text, maximum flexibility in model selection, OpenAI API compatibility for existing applications, and advanced features like semantic search and autonomous agents. Works efficiently even without dedicated GPUs. To get up and running, the LocalAI QuickStart covers Docker installation, model gallery setup, CLI flags, and API usage end-to-end. — [source](https://www.glukhov.org/llm-hosting/comparisons/hosting-llms-ollama-localai-jan-lmstudio-vllm-comparison/) ## How-to and procedures - The What you can paste panel beside the field lists every accepted scheme: huggingface://, hf://, a full Hugging Face URL, any direct https:// URL, file:// and absolute paths on the host, oci://, ocifile://, and ollama://. — [source](https://localai.io/docs/getting-started/models/) - LocalAI supports **60+ backends** including llama.cpp, vLLM, SGLang, transformers, whisper.cpp, diffusers, MLX, MLX-VLM, and many more. Hardware acceleration is available for **NVIDIA** (CUDA 12/13), **AMD** (ROCm), **Intel** (oneAPI/SYCL), **Apple Silicon** (Metal), **Vulkan**, and **NVIDIA Jetson** (L4T). All backends can be installed on-the-fly from the [Backend Gallery](https://localai.io/backends/). — [source](https://github.com/mudler/LocalAI#supported-backends-acceleration) - LocalAI is designed to run on consumer-grade hardware without GPU, making it accessible for initial exploration. Ollama benefits significantly from GPU acceleration but supports CPU-only operation for smaller models. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - To work with a running LocalAI server from the terminal, start the built-in agent from another shell. It answers questions, reads your files and runs commands on your machine, asking you to approve anything that changes state. Inside a session, `/models` lists installed models and `/model ` switches between them. See the [Terminal agent](https://localai.io/docs/features/terminal-agent/) docs. — [source](https://github.com/mudler/LocalAI#loading-models) - LocalAI is engineered as a drop-in replacement for the OpenAI API, allowing developers to use existing OpenAI SDKs and tools with local models seamlessly. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - LocalAI is designed to run on consumer-grade hardware without requiring a GPU, though performance improves significantly with GPU acceleration. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) ## Examples and snippets - ```bash — `# From the model gallery (see available models with `local-ai models list` or at https://models.localai.io)` … — [source](https://github.com/mudler/LocalAI#loading-models) - ```bash — `# Terminal 1` … — [source](https://github.com/mudler/LocalAI#loading-models) - ```bash — `docker run -ti --name local-ai -p 8080:8080 localai/localai:latest` … — [source](https://github.com/mudler/LocalAI#cpu-only) - ```bash — `# CUDA 13` … — [source](https://github.com/mudler/LocalAI#nvidia-gpu) - ```bash — `docker run -ti --name local-ai -p 8080:8080 --device=/dev/kfd --device=/dev/dri --group-add=video localai/loca` … — [source](https://github.com/mudler/LocalAI#amd-gpu-rocm) - ```bash — `docker run -ti --name local-ai -p 8080:8080 --device=/dev/dri/card1 --device=/dev/dri/renderD128 localai/local` … — [source](https://github.com/mudler/LocalAI#intel-gpu-oneapi) - ```bash — `docker run -ti --name local-ai -p 8080:8080 localai/localai:latest-gpu-vulkan` … — [source](https://github.com/mudler/LocalAI#vulkan-gpu) - ``` — `@misc{localai,` … — [source](https://github.com/mudler/LocalAI#citation) ## Measurements and reference values - LocalAI installs models from its gallery (`local-ai run llama-3.2-1b-instruct:q4_k_m`), Hugging Face (`huggingface://TheBloke/phi-2-GGUF/phi-2.Q8_0.gguf`), the Ollama OCI registry (`ollama://gemma:2b`), generic OCI registries (`oci://localai/phi-2:latest`), or a remote or local YAML config. — [source](https://github.com/mudler/LocalAI) - local-ai run huggingface://TheBloke/phi-2-GGUF/phi-2.Q8_0.gguf local-ai run ollama://gemma:2b local-ai run https://gist.githubusercontent.com/.../phi-2.yaml local-ai run oci://localai/phi-2:latest — [source](https://localai.io/docs/getting-started/models/) - local-ai models install llama-3.2-1b-instruct:q4_k_m — [source](https://localai.io/docs/getting-started/models/) - local-ai run llama-3.2-1b-instruct:q4_k_m — [source](https://localai.io/docs/getting-started/models/) - local-ai run ollama://gemma:2b — [source](https://localai.io/docs/getting-started/models/) - Two platforms have emerged as the leading solutions: Ollama with over 160,000 GitHub stars and LocalAI with 35,000+ stars. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - local-ai models install hermes-2-theta-llama-3-8b — [source](https://localai.io/docs/getting-started/models/) - $ docker run -p 8080:8080 --name local-ai -ti localai/localai:latest starting local-ai detected: CPU (AVX-512), 32 GB RAM API ready on http://localhost:8080 — [source](https://localai.io/) - You’re spending thousands monthly on OpenAI and want full API compatibility without vendor lock-in. LocalAI’s drop-in replacement supports your existing code while cutting costs by 80% with on-premise deployment. Get cloud engineer rates → — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) ## Problems, failure modes and limitations - While you type, the page reads the spelling of the source (Hugging Face repository, direct URL, configuration file, OCI image, Ollama model, or a path on the host) and shows the request the form will send. It also runs the checks that can be made before the import starts: whether the name is already in use, whether the chosen backend is installed, and how much disk and memory are free. The server returns no preview of the model configuration, the size or the memory a model needs before the import starts, so the page does not show them. They appear once the import starts, next to the free memor — [source](https://localai.io/docs/getting-started/models/) - Your product requires text, image, audio, and video AI capabilities. LocalAI’s comprehensive multimodal support handles all formats through one API, while Ollama focuses primarily on text models. Find full-stack AI talent → — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - For file:// model paths, LocalAI requires the path to be inside the models directory (MODELS_PATH); paths outside are rejected. — [source](https://localai.io/docs/getting-started/models/) - LocalAI provides more enterprise security features including API key authentication, rate limiting, and fine-grained access control, but requires more careful configuration. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) ## Comparisons and alternatives - Compared with Ollama, which uses llama.cpp as its backend with a curated library, LocalAI offers multiple engines, multimodal coverage (image, audio, TTS, video) and fuller OpenAI tools API support, but with more moving parts and configuration. — [source](https://www.glukhov.org/llm-hosting/comparisons/hosting-llms-ollama-localai-jan-lmstudio-vllm-comparison/) - LocalAI vs Ollama: Differences, Use Cases, and Trade-offs in 2026 — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - For high-concurrency production workloads, specialized platforms like vLLM achieve significantly higher throughput (793 TPS versus Ollama’s 41 TPS in benchmarks). — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - Ollama provides its own API but also offers an OpenAI-compatible endpoint for basic use cases. The compatibility is less comprehensive than LocalAI’s, particularly for advanced features like function calling and multimodal operations. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - Tool Calling Support: node-llama-cpp requires manual implementation of tool calling through prompt engineering and output parsing. Unlike API-based solutions with native function calling, you must handle the entire tool calling workflow in your JavaScript code: defining tool schemas, injecting them into prompts, parsing model responses for function calls, executing the tools, and feeding results back to the model. While this gives you complete control and flexibility, it’s significantly more work than using vLLM or LocalAI’s built-in support. node-llama-cpp is best for developers who want to b — [source](https://www.glukhov.org/llm-hosting/comparisons/hosting-llms-ollama-localai-jan-lmstudio-vllm-comparison/) - TL;DR: Ollama excels in simplicity with 160K GitHub stars. LocalAI offers full OpenAI API compatibility with multimodal support. Choose based on complexity needs. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - LocalAI positions itself as a comprehensive AI stack, going beyond text generation to support multimodal applications. This flexibility comes with additional complexity compared to Ollama’s streamlined approach. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - Leaving the backend on auto-detect lets LocalAI choose from the source. Selecting a backend sends an explicit backend preference in the previewed request. If more than one installed backend can serve the detected modality, the page says so and offers the candidates inline — picking one resubmits the import. — [source](https://localai.io/docs/getting-started/models/) - PulumiDeploy low-code LLM apps on AWS with Flowise and LocalAIA full EKS deployment, with LocalAI doing inference and no GPU in the cluster. SemaphoreLocalAI: replacing OpenAI API with open-sourceSwapping an existing OpenAI integration over to LocalAI, endpoint by endpoint. Spectro CloudK8sGPT + LocalAI: unlock Kubernetes superpowers for freeCluster diagnosis through K8sGPT, answered by a model running on CPU. SUSEA four-part series on running AI locallyInstall on openSUSE and drive it from VS Code, add your own documents with RAG, put a Confluence space behind a local model, then train a LoRA — [source](https://localai.io/) ## Changes and history - - **October 2026**: **LocalAI 4.11.0** — Audio scenes with transcription, speaker labels, and sound detection. Also the Decisions API (`/v1/systemone`), model failover chains, signed OCI galleries, and Kimodo text-to-animation. [Release notes](https://github.com/mudler/LocalAI/releases/tag/v4.11.0) - **September 2026**: **LocalAI 4.10.0** — A fleet operations dashboard, one credentials file for private model sources, and `local-ai benchmark` for measuring model latency and throughput. [Release notes](https://github.com/mudler/LocalAI/releases/tag/v4.10.0) - **August 2026**: **LocalAI 4.9.0** — — [source](https://github.com/mudler/LocalAI#latest-news) - On every model download — Ollama and OCI registries, the model gallery, and plain HTTP(S) file URLs alike — LocalAI identifies itself with a LocalAI/ (; ) User-Agent header (for example LocalAI/v3.2.1 (linux; amd64)) so registry and gallery operators can attribute usage to LocalAI. Builds from source that carry no stamped version send LocalAI (; ) instead. — [source](https://localai.io/docs/getting-started/models/) - LocalAI offers drop-in API compatibility with OpenAI, Anthropic and ElevenLabs. A drop-in Ollama API was added in release 4.2.0 (May 2026), so Ollama clients can point at LocalAI. — [source](https://github.com/mudler/LocalAI) - Release cadence is fast: README news lists LocalAI 4.11.0 in October 2026, with 4.9.0 adding deny-by-default authentication and unified model and backend management, and 4.11.0 adding signed OCI galleries and model failover chains. — [source](https://github.com/mudler/LocalAI) - LocalAI is container-first and adds setup complexity. Security features such as API keys and rate limiting need careful configuration, and it has no native desktop app. Release 4.9.0 moved to deny-by-default authentication. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - For older news and full release notes, see [GitHub Releases](https://github.com/mudler/LocalAI/releases) and the [blog](https://localai.io/blog/). — [source](https://github.com/mudler/LocalAI#latest-news) - LocalAI binary releases are available on GitHub. — [source](https://localai.io/docs/getting-started/models/) - $ curl -sSL https://localai.io/install.sh | sh detecting platform linux/amd64 fetching latest release binary installed to /usr/local/bin/local-ai — [source](https://localai.io/) ## Facts and statements - The ollama:// scheme lets LocalAI pull models from the Ollama registry, so Ollama-library content is reachable without running Ollama. — [source](https://localai.io/docs/getting-started/models/) - local-ai run huggingface://TheBloke/phi-2-GGUF/phi-2.Q8_0.gguf — [source](https://localai.io/docs/getting-started/models/) - wget https://huggingface.co/TheBloke/phi-2-GGUF/resolve/main/phi-2.Q4_K_M.gguf \ -O models/phi-2.Q4_K_M.gguf — [source](https://localai.io/docs/getting-started/models/) - wget https://huggingface.co/TheBloke/Luna-AI-Llama2-Uncensored-GGUF/resolve/main/luna-ai-llama2-uncensored.Q4_0.gguf -O models/luna-ai-llama2 — [source](https://localai.io/docs/getting-started/models/) - LocalAI Multimodal AI, flexibility ⭐⭐⭐⭐⭐ Stable ✅ Full Web UI GGUF, PyTorch, GPTQ, AWQ, Safetensors NVIDIA, AMD, Apple ✅ Yes — [source](https://www.glukhov.org/llm-hosting/comparisons/hosting-llms-ollama-localai-jan-lmstudio-vllm-comparison/) - Repositories under mlx-community are imported with the native MLX backend. LocalAI uses Hugging Face’s pipeline metadata to select mlx-vlm for vision-language models and mlx-audio for text-to-speech models; other MLX repositories use mlx. An explicit backend selection in the import form always overrides this automatic routing. — [source](https://localai.io/docs/getting-started/models/) - File Format Support: Depends on connected backends (typically GGUF via Ollama/LocalAI). — [source](https://www.glukhov.org/llm-hosting/comparisons/hosting-llms-ollama-localai-jan-lmstudio-vllm-comparison/) - For production deployments, LocalAI can route requests to external high-performance backends like vLLM while maintaining the unified OpenAI-compatible API. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - Model Library: Curated repository at ollama.com/library — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - Note: The galleries available in LocalAI can be customized to point to a different URL or a local directory. For more information on how to setup your own gallery, see the Gallery Documentation. — [source](https://localai.io/docs/getting-started/models/) - huggingface://repository_id/model_file (e.g., huggingface://TheBloke/phi-2-GGUF/phi-2.Q8_0.gguf) — [source](https://localai.io/docs/getting-started/models/) - File Formats: GGUF, GGML, Safetensors, PyTorch, GPTQ, AWQ — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - LocalAI’s model gallery provides pre-configured models, but the platform also supports custom configurations for specialized deployments. This flexibility serves teams requiring fine-tuned or specialized models across different modalities. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - LocalAI auto-detects GPU capability (NVIDIA CUDA 12/13, AMD ROCm, Intel oneAPI, Vulkan, Apple Silicon, Jetson) and downloads the matching backend. CPU-only operation is supported. — [source](https://github.com/mudler/LocalAI) - > **Automatic Backend Detection**: LocalAI automatically detects your GPU capabilities and downloads the appropriate backend. For advanced options, see [GPU Acceleration](https://localai.io/features/gpu-acceleration/). — [source](https://github.com/mudler/LocalAI#loading-models) - local-ai run huggingface://TheBloke/phi-2-GGUF — [source](https://localai.io/docs/getting-started/models/) - Most backends wrap a best-in-class upstream engine. A handful of them are native C/C++/GGML engines (no Python at inference) developed and maintained by the LocalAI project itself: — [source](https://github.com/mudler/LocalAI#backends-built-by-us) - LocalAI: OpenAI-Compatible Local LLM Server with Multimodal Support — [source](https://www.glukhov.org/llm-hosting/comparisons/hosting-llms-ollama-localai-jan-lmstudio-vllm-comparison/) - API Maturity: Highly mature as full OpenAI drop-in replacement supporting all OpenAI endpoints plus additional features. Includes full streaming support, native function calling via OpenAI-compatible tools API, image generation and processing, audio transcription (Whisper), text-to-speech, configurable rate limiting, and built-in API key authentication. LocalAI excels at tasks like converting HTML content to Markdown using LLM thanks to its versatile API support. — [source](https://www.glukhov.org/llm-hosting/comparisons/hosting-llms-ollama-localai-jan-lmstudio-vllm-comparison/) - LocalAI takes a different approach as a comprehensive OpenAI-compatible API gateway supporting text, image, audio, and video generation. ‘ — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - LocalAI’s flexibility enables complex deployments where a single OpenAI-compatible endpoint routes to multiple specialized backends. This architecture serves teams requiring specialized or fine-tuned models across different modalities. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - An OpenAI-compatible API in front of llama.cpp, so a laptop could answer the same calls as the cloud. — [source](https://localai.io/) - API Maturity: Stable for connecting to existing installations. No separate server required as it extends functionality of other tools like Ollama and LocalAI. — [source](https://www.glukhov.org/llm-hosting/comparisons/hosting-llms-ollama-localai-jan-lmstudio-vllm-comparison/) - Understanding the architectural differences between Ollama and LocalAI reveals why each platform excels in different scenarios. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - The multimodal story strongly differentiates these platforms. While Ollama focuses primarily on text generation, LocalAI provides comprehensive support for multiple modalities. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - LangChain: Native integrations for both Ollama and LocalAI — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - For new projects exploring local LLMs, Ollama provides the fastest path to running models. For organizations with existing OpenAI-based applications or multimodal requirements, LocalAI’s API compatibility reduces migration effort. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - Many teams benefit from using both: Ollama for development and exploration, LocalAI for production deployments requiring advanced features. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - Hire vetted remote AI developers with Second Talent to deploy secure local LLM infrastructure using Ollama, LocalAI, or enterprise AI platforms. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - name: phi-2 parameters: model: phi-2.Q4_K_M.gguf temperature: 0.7 context_size: 2048 threads: 4 backend: llama-cpp — [source](https://localai.io/docs/getting-started/models/) - Created by [Ettore Di Giacinto](https://github.com/mudler) and maintained by the [LocalAI team](#team). — [source](https://github.com/mudler/LocalAI) - This section covers everything you need to know about installing and configuring models in LocalAI. You’ll learn multiple methods to get models running. — [source](https://localai.io/docs/getting-started/models/) - local-ai run oci://localai/phi-2:latest — [source](https://localai.io/docs/getting-started/models/) - docker run -p 8080:8080 -v $PWD/models:/models -ti --rm localai/localai:latest --models-path /models --context-size 700 --threads 4 — [source](https://localai.io/docs/getting-started/models/) - local-ai backends list local-ai backends install llama-cpp # if needed — [source](https://localai.io/docs/getting-started/models/) - What landed in LocalAI 4.11 — [source](https://localai.io/) - $ podman run -p 8080:8080 --name local-ai -ti localai/localai:latest — [source](https://localai.io/) - $ kubectl apply -f https://localai.io/install/kubernetes.yaml deployment.apps/local-ai created service/local-ai created — [source](https://localai.io/) - LocalAI positions itself as a comprehensive AI stack, going beyond just text generation to support multimodal AI applications including text, image, and audio generation. — [source](https://www.glukhov.org/llm-hosting/comparisons/hosting-llms-ollama-localai-jan-lmstudio-vllm-comparison/) - This comprehensive multimodal support makes LocalAI suitable for applications requiring multiple AI capabilities through a single deployment. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - LocalAI provides full OpenAI API compatibility, enabling teams to switch from OpenAI to local models with minimal code changes. Simply update the base URL and API key. This compatibility extends to: — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - For multi-tenant SaaS platforms, LocalAI’s model management and resource isolation capabilities provide flexibility. Teams can route different tenants or use cases to optimized backends while maintaining a consistent API surface. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - LocalAI’s comprehensive OpenAI compatibility and multimodal support serve teams migrating from cloud APIs or building complex AI applications. — [source](https://www.secondtalent.com/resources/localai-vs-ollama-differences-use-cases-and-trade-offs/) - The format is: huggingface:/// ( is optional) — [source](https://localai.io/docs/getting-started/models/) - Method 1: Using the Model Gallery (Easiest) — [source](https://localai.io/docs/getting-started/models/) - The same Models page owns the complete lifecycle. Switch to Installed to search local configurations, filter them by running, idle, disabled, pinned, or distributed state, and open a model’s runtime controls. Load and stop are on each row; edit, pin, disable, backend logs, and remove are in the row menu and in the details of the selected model. The current view, search, filter, and selection are stored in the URL so links and browser history preserve your place. The disk strip in the page header shows the free space on the models disk and opens a review of what can be removed to free more (see — [source](https://localai.io/docs/getting-started/models/) - GGUF: Modern format, recommended for most use cases — [source](https://localai.io/docs/getting-started/models/) ## Related concepts - [LocalAI](https://llms-explorer.com/tree/localai/) — is a hyponym of LocalAI relative to Ollama - [Ollama](https://llms-explorer.com/tree/ollama/) — is a related of LocalAI relative to Ollama - GGUF — is a part of LocalAI relative to Ollama - model gallery — is a part of LocalAI relative to Ollama - quantization — is a part of LocalAI relative to Ollama - Llama — is a instance of LocalAI relative to Ollama - inference engine — is a part of LocalAI relative to Ollama - GGUF publisher — is a instance of LocalAI relative to Ollama - OpenAI-compatible — is a part of LocalAI relative to Ollama - Hugging Face Hub — is a hyponym of LocalAI relative to Ollama - Gemma — is a instance of LocalAI relative to Ollama - OCI registry — is a part of LocalAI relative to Ollama - pull counts — is a measure of LocalAI relative to Ollama - GGML — is a part of LocalAI relative to Ollama - Ollama library — is a hyponym of LocalAI relative to Ollama - Safetensors — is a part of LocalAI relative to Ollama - hf.co/ — is a part of LocalAI relative to Ollama - ollama:// — is a part of LocalAI relative to Ollama - curated catalog — is a part of LocalAI relative to Ollama - Docker Hub — is a part of LocalAI relative to Ollama